COMMENT ⊗   VALID 00032 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00005 00002	Recent NEWS about E, newest news first.
C00046 00003	INDEX of commands.
C00070 00004	Abbreviations and explanation of E documentation.  Credits.
C00074 00005	General remarks.
C00082 00006	PAGE CHANGING, APPENDING, DIVIDING and COMBINING: XAPPEND β<ff> XMARK XDELETE
C00091 00007	WINDOW and ARROW moving commands.
C00102 00008	LINE MARKING commands.
C00105 00009	LINE-EDIT commands.
C00121 00010	Attach and Copy commands: A C
C00130 00011	LINE-INSERT mode.
C00135 00012	Handling very long lines.  XBREAK XJOIN
C00139 00013	SEARCH (or FIND) commands: F XFIND * XEXACT F<string>P F<string>:
C00155 00014	SUBSTITUTION commands: \
C00167 00015	FILE-SWITCHING and text transfering commands: ε λ ∃ ? XPOINTER
C00182 00016	Justification: XJFILL XJUST XJGET XSJFILL XSJUST
C00206 00017	Commands for tabular material: XTABLE XTJFILL XTJUST XTJGET
C00222 00018	MARGIN CONTROL commands: XALIGN XINDENT → ← XCENTER
C00231 00019	Other EXTENDED commands: X<cmd>
C00259 00020	System commands and file SWITCHES.
C00280 00021	Using E from a non-display (TTY).
C00293 00022	PARENTHESIS finding/matching commands: ( ) XLPAREN XRPAREN ↔ XPAREN XPINFO
C00309 00023	Swapping To and From E via RPG startups: XRSYS XRUN XGORPG XDRD XTV
C00315 00024	Message and paragraph handling commands: ∂<cmd> 0∂ !<cmd> 0!
C00327 00025	MACROS: XDEFINE Z Y XRESUME XABORT # XSTOPALL XSTOPONE XSTOPZERO XSTOPHOW
C00350 00026	MACROS AND COMMAND FILES: XEXECUTE PUTDEFS XCOMMENT XATTACH XREDEFINE
C00357 00027	BOOK MODE (/B) and the BOOK command
C00364 00028	E files extended by other programs.
C00368 00029	Filenames, numeric extensions, and filehacks
C00375 00030	Generating a new directory line: XNDFAIL XNDSAIL
C00380 00031	Major changes have been made to the JUST and JFILL commands (9/5/76).
C00387 00032	N,O,H: Line, Page & File stacks. XHOME XBACKGO XZFILES XZPAGES XZLINES
C00402 ENDMK
C⊗;
Recent NEWS about E, newest news first.
  Index of E commands is on p. 3.
  A history of E changes is in E.UPD[UP,DOC].

∂09 Apr 78 -- Minor improvements to ⊗XPOINTER command.

The ⊗XPOINTER command no longer recognizes filenames in the text that are
less than four characters long (including their switches), except for
filehacks, which can be any length.  Thus "A.I" and "F/X" will not be taken
as filenames.

Also, a numeric argument can be given to the ⊗XPOINTER command to have it
find the nth filename in the text; thus it is now possible to switch to
any of several files all named on a given line.  An arg of the form ⊗#
will make E merely type out the #th filename, without moving the arrow and
without switching files.  An arg of the form ⊗+⊗# means switch to the #th
file named in the text; this is conveniently done right after the ⊗# form
has verified that the filename found was the one you wanted to switch to.
Since ⊗# doesn't normally move the arrow (so that you can then say ⊗+⊗#
without having changed the significance of the number), an arg of the form
⊗-⊗# finds the #th filename and moves the arrow to that line but doesn't
switch files.

Summary of meanings of ⊗XPOINTER args:

  arg	meaning

 (none)	Switch to first file named in the text at or below current line.
   ⊗0	Type out the first filename in the text, and move to its line.
  ⊗-⊗#	Type out the #th filename in the text, and move to its line.
   ⊗#	Type out the #th filename in the text (without moving).
  ⊗+⊗#	Switch to the #th file named in the text.

∂06 Apr 78 -- ⊗-⊗XNUMBERS made default (no line numbers typed out).

Users who want line numbers typed out with the text must now enable them
by giving the ⊗XNUMBERS command, since the default is now to omit the
line numbers (by popular demand).

Also, the ⊗L command (move to specific line) is now permitted from the
line editor.  Note that to get this command to E, however, you must
either (1) type αβL rather than αL, which is a line editor command, or
(2) precede the ⊗L with a (signed or unsigned) argument.  And to enter
an unsigned argument from the line editor, the first digit must be typed
with both α and β (since α<digit> is taken as a line editor argument and
doesn't get to E).

∂01 Apr 78 -- New ⊗XPOINTER cmd, justification simplifications,
    plus ⊗0⊗∃ and ⊗0αβM replaced, new commands to clear stacks, and more.

The new ⊗XPOINTER command is used to switch to a file whose name is
found in the text of the page you are editing, at or below the current
line.  With an argument of zero, the command ⊗0⊗XPOINTER will merely
move to the line containing the filename found (if any) and type out the
filename, but will not switch files.  The command with no argument moves
the arrow to the line containing the filename found (if any) before
attempting to switch files.

A filename in the text will not be recognized unless it is preceded by a
space (or tab) or occurs at the beginning of a line.  Furthermore, to be
accepted by this command, a filename must have at least one of these:
(1) an explicit (non-null) extension, (2) an explicit (complete) PPN,
(3) one or more switches, or (4) a valid filehack.  Spaces are permitted
only as leading spaces in PPNs for blank characters in the project or
programmer name, and a filename with its switches must occur all on one
line.  Thus the following filenames will be recognized:

FILE/-R, FILE.E, FILE[J,G], FILE.EXT[J,G](R9P7L), FILE.[ J, G], \GRIPES.

The following will NOT be accepted: FILE., FILE[X], FILE/6PR, F[ ABC,D].
The only characters permitted in names within the filename are letters
(case of letters is ignored), digits, and the underbar character (which
represents a quoted space).  In particular, the down-arrow construction,
the partial-sign name, and the question-mark name are not permitted in
filenames.  Also note that only the first filename on a line will ever
be detected.

Any switches following a filename in the text will be observed in
switching to that file.  In addition, any text in the extended command
line after the name of the command will be appended to the filename and
switches found in the text.  Thus additional (or overriding) switches
can be specified, or if no PPN or switches appear in the text, an
explicit PPN can be added.  Switches in the text must be perfectly
well-formed or the filename they are applied to will not be recognized.
This means that parentheses must be balanced and no letter or digit can
immediately follow the letter of a slash-type switch.  However, the
actual letters of switches are not checked for validity (as indeed they
never are by E -- undefined switches are completely ignored).

This command's default mode for switching to a file is readonly (/R).
However, this can be overriden with an explicit /-R occurring among the
switches in the text or typed in the command line after the extended
command name (e.g., ⊗XPOINTER /-R<cr>).

When you attempt to switch files with this command, if the file named in
the text cannot be edited because it does not exist, is busy, etc., E will
abort the fileswitching operation automatically (nevertheless having
written out the current page before attempting to switch files).  If,
however, the combined (text and command line) filename with switches has
an illegal syntax, E will say so and then load your line editor (on
displays) with the combined text so that you can correct it and try again.


CLEARING STACKS AND LINE MARKS:

The commands ⊗0⊗∃ and ⊗0αβM no longer clear the file stack and line mark
list.  These commands have been replaced with explicit extended commands.
Also, two new extended commands are provided for clearing the page and
line stacks.  These four new commands are:

    ⊗X ZFILES        ;Zero (clear) the file stack
    ⊗X ZPAGES        ;Zero (clear) the page stack
    ⊗X ZLINES        ;Zero (clear) the line stack
    ⊗X ZMARKS        ;Zero (clear) all line marks


JUSTIFICATION SIMPLIFICATION: REMOVAL OF SWITCHES (MODES)

The justification commands in E no longer accept the various switches
formerly used.  Now a simple procedure is used to determine where
paragraph breaks occur in the input text being justified.  For
justification purposes, a new paragraph is indicated by (1) an empty line
or (2) a line indented exactly the right amount (that is, a line having
the right number of leading blank columns, whether tabs or spaces or both
are used to make the indentation).

The amount of indentation that indicates a paragraph in the input text
will be called the DETECT-PARAGRAPH margin, or simply the DETECT margin.
Note: If you haven't set the detect margin explicitly (see below), and if
the crown margin and the left margin are the same, then only blank lines
will indicate new paragraphs in the input text (otherwise every line would
become a separate paragraph).

The detect margin is normally the same as the crown margin.  However, for
changing the crown margin of justified text that has no blank lines
between paragraphs, the detect margin can be set explicitly to any value.
The detect margin can be set in any justification command by typing its
value immediately after the extended command name and following it with a
slash ("/").  After the slash, the normal margins (crown, left, right,
blank) can be specified, separated by commas.  For instance, the command
⊗XJUST 8/7<cr> would set the detect margin to 8 (for paragraphs indented
with one tab or eight spaces) but would cause the text to be rejustified
so that each paragraph was indented only 7 spaces.  Note that the detect
margin is sticky until you change either the crown margin, the left
margin, or the detect margin itself.  Thus after the above command, E
would no longer recognize the new crown lines (now indented 7 spaces) as
such since the detect margin would still be 8.  The detect margin can be
set without changing any of the other margins, as in ⊗XJUST 7/<cr>.  The
command ⊗XJUST 8<cr> explicitly sets the crown margin to 8 and implicitly
also sets the detect margin to 8.

To find out the current margins and what indicates a paragraph, use an
argument of zero with a justification command, for example ⊗0⊗XJFILL<cr>.

This change affects the extended commands:
	JUST JFILL JGET SJUST SJFILL  TJUST TJFILL TJGET
Note that the last three of these use a separate set of margins (detect,
crown, left, etc.) from the rest.


EXTENSION TO FILEHACKS FOR SPECIFYING A PROGRAMMER NAME:

The filehacks \MAIL, \PLAN, and \NS can now have an explicit programmer
name specified, in which case the mail, plan, or notification file for the
named programmer is read instead of your own.  To specify a programmer
name, follow the filehack name immediately with a colon (:) followed by
the desired programmer name.  For instance, \MAIL:FOO represents FOO's
mail file, and \PLAN:BAZ is BAZ's plan file.  The new ⊗XPOINTER command
will recognize these programmer-name filehacks (as well as the normal
filehacks).  The filehack names themselves can be abbreviated as usual
(e.g., \M:FOO is FOO's mail file).  The programmer-name filehack facility
is designed for non-display users, since display users could already enter
a filename like ∂FOO or ∂BAZ.PLN.


MAILING FROM E WHEN THERE ARE NO JOB SLOTS:

When there are no job slots for E to start up a MAIL job, mail sent from E
is now queued (by writing it into a special file on RMD,SYS which will get
processed later automatically).  You are told when this is happening, and
you will eventually be notified of the success or failure of the mail
delivery.

Also, whenever the MAIL program detects an error in mail coming from E, it
will now mail the whole message and command back to the sender with an
appropriate message prefixed to it.


BUG FIXES:

Bug fix to ⊗XJOIN given on an empty line.
Bug fix for αβV typed from line editor.
⊗XREDFINE and ⊗XDEFINE called from inside a macro and ⊗XEXECUTE called at
  any time no longer change the current default macro called by the ⊗Y
  command.

∂17 Mar 78 -- Window position saved/restored with line stack.

E now remembers the window position of each line in the line stack.  When
you return to a line via ⊗N, the old window associated with that line is
restored unless the line was already on the screen, in which case the
window is not changed.

∂15 Mar 78 -- Bug fixed; window restored on returning to a file.

Bug fixed to properly remember in tmpcor file the values of the /R switch
for all filenames written in tmpcor.

Also, the window position is now preserved and restored upon switching
files and returning.  Currently, the window positions for page stack
entries are not written out in the tmpcor file, except for the last page
and line you were at in the file.

∂14 Mar 78 -- Improved line insert mode (affects display users only):

    IMPORTANT CHANGES to ⊗I, αβ<cr>, αβ↑, αβ↓, αβ. and new αβ<tab>.

It is now possible to get into line insert mode without having a new blank
line added.  To do this, type either αβI from the middle of the line
editor (that is, while editing a line) or ⊗I from the end of the line
editor.  These commands will turn on line insert mode and leave you
positioned wherever you are, but the next <cr> you type will create a new
line.  Note that, having used ⊗I thusly, if you then type <altmode> with
any text in the line, that text will be saved -- the altmode will not
restore any version of that line that existed before you edited it.  If
you don't want the final edited text you have, you can get back the text
as of the ⊗I command by clearing the line editor (e.g., type <clear>) and
then typing <altmode>.  This means that ⊗I from the line editor (not
including αI when interpreted as a line editor command) saves the current
text of the line (in core -- not on the disk) thus preventing you from
getting back (with altmode) a previous version of that line.

There has also been a small constructive change made to the αβ<cr> command
when given from the middle (not end) of the line editor.  This command now
breaks the current line in two, as before, but instead of inserting a
blank line between the two halves and leaving you there in line insert
mode, it merely leaves you at the end of the first part of the line in
line insert mode, without adding a new blank line.  This new effect should
be much more useful than the old version.

Note that these changes make αβI behave differently from αβ<cr> when in
the line editor.  The meanings of these two commands outside the line
editor are unchanged; in that case αβI and αβ<cr> do the same thing,
namely, put you into line insert mode on a new blank line.  Also, whenever
any numeric argument is given to either of these commands, the old meaning
is still in effect -- namely, to insert N blank lines (and not leave you
in line insert mode).

To make line insert mode on old text lines easier to get into, two old
commands and one new one have been made to enter line insert mode if both
α and β are on.  These commands are αβ<tab> and αβ↑ and αβ↓.  The latter
two still go to the end of the line above or below, but now also enter
line insert mode.  The αβ<tab> command is just like α<tab> (goes to the
end of the current line) except that it also enters line insert mode.
Notice again that if you type αβ<tab> while in the line editor, the line
editor text is saved at that point and a subsequent <altmode> has its
usual line-insert-mode meaning.

Another important (and related) new feature is the ability to write out
the page from the line editor with the αβ. command (must have both α and β
in order to work).  This command writes out (to the disk) the text that is
currently in the line editor (as well as the rest of the page) and then
leaves you in the line editor (in line insert mode if you were in it
before).  A subsequent <altmode> typed on that line will not restore the
original text of the line; if you are NOT in line insert mode, it will
restore the text that was written out, and if you ARE in line insert mode,
the <altmode> will have its usual line-insert-mode effect.  Note that
writing out the page from inside the line editor may cause E to Ripple the
file, even though you may not see any X (or W even) on the header line,
since the display is not updated before writing the page out.

Remember that in all cases, if you type <altmode> from a NON-EMPTY line
editor while in line insert mode, the line editor text is retained for
that line and you leave line insert mode.  If you type <altmode> from an
EMPTY line editor in line insert mode, you leave line insert mode with
either the saved text (if any) for that line restored (if you typed ⊗I or
⊗<cr> or αβ. in that line) or the (empty) line deleted.

∂12 Mar 78 -- Improvements in new stuff.
	(See next message first, if you haven't already read it).

Editing a file that has been extended (e.g., a message file) starts at the
  FIRST NEW PAGE if the file either (1) is named explicitly (with no
  page-specifying switch, e.g., ⊗ε∂<cr>), (2) is the first file edited in
  that core image (e.g., ET ∂<cr> or ET<cr>), or (3) has changed between
  exiting and CONTINUing.  Otherwise, an extended file will be edited
  starting at the page and line where you were when you left that file
  (that is, switching files by explicit number (e.g., ⊗2⊗λ) or with the ⊗H
  command will always return you to the page and line you were previously
  positioned at, even if the file has been extended before or since then).
Whenever the /nP switch is used to start editing at page n, the default
  line (if no line switch is given) is now always line 1.
Filenames read from tmpcor are assumed complete, even though they may
  contain no device name or PPN.
The ⊗XHOME command (old ⊗H cmd) now uses (the top of) the new file stack
  (for going to a relative or absolute page in home file).
The /-R switch now properly disables readonly mode even if ⊗λ was given.
The ⊗XTMPCOR command now forces subsequent exiting and file switching to
  write out the tmpcor file, making it appear you used a standard E
  monitor command (like ETV) to run E (instead of using, e.g., the monitor
  command R E, which normally suppresses writing out of the tmpcor file).

∂10 Mar 78 -- Tmpcor file now includes top three files in stack, plus page stacks.

 E now remembers in its tmpcor file the top three files of your file
  stack, plus the top part of the page stack of each file.  Thus these
  files will be restored to your file stack when you next give an ETV or
  EREAD monitor command, whether or not that command specifies a file to
  edit.  Line marks are remembered and restored for each of the three
  files remembered.  Remember that you can flush your file stack (should
  it get too cluttered) with the command ⊗0⊗∃, which makes E forget about
  all files but the one you are in.

 To allow specifying page stack entries in switches (e.g., in tmpcor
  files), a new switch has been added: /x,yO pushes the place of page x
  and line y onto the page stack.  This switch cannot, however, be used
  when editing (by explicit name) a file which E already knows about,
  since in that case E will restore the file's previous page stack.

 To allow multiple files to be specified (e.g., in tmpcor files), E has
  been made to accept multiple filenames (and switches), separated by
  commas.  Multiple filenames can be typed whenever E is accepting the
  name of a file to be edited (e.g., in the original monitor command or in
  the ⊗ε or ⊗λ filename line).  The first file listed will be edited and
  the rest will be pushed (in the order given) onto the file stack (this
  means that the second file listed will end up pushed most deeply in the
  stack and the last file listed will end up near the top of the stack.
  Note that if you are switching files (except by ⊗+⊗H or ⊗-⊗H), the file
  you are leaving will end up being pushed onto the stack AFTER the
  additional filenames you give in the filename line.

 Editing a previous file by explicit name (e.g., ETV FOO or ⊗εFOO<cr>) now
  positions you at the page and line where you left that file (unless you
  specify otherwise with switches, or unless that file has had some pages
  added and you haven't actually edited it with the current core image, in
  which case the default position is still the first added page).  Note
  also that line marks and the page stack for that file are restored even
  when switching by explicit name.  Thus switching by explicit name now
  restores everything that switching by any other mechanism restores,
  except for readonly status, which is implied by the ⊗ε or ⊗λ (but which
  can be overriden with /R).

 The new extended command ⊗XTHISPAGE is useful for going from multipage
  mode (two or more pages in core) to single page mode (one page in core).
  This command writes out the incore text and then reads in only the page
  where the arrow is.  The position of the arrow and (when possible) the
  window are preserved.  However, the line stack is currently cleared.

 The extension S1 has been added to E's good extension list, and the
  extensions LDI and RIM have been added to the bad list (file never
  edited unless extension given explicitly or unless only one file exists
  with the given primary name).

 Readonly mode is forced (and announced) on an attempt to edit any
  non-formatted file that is write-protected from you.  Formerly, you got
  the error halt "ENTER FAILED, PROTECTION VIOLATION" upon an attempt to
  edit such a file.

 A bug has been fixed which caused any appropriate /N to be left out of
  the tmpcor file and the header line whenever the filename extension was
  blank.

∂03 Mar 78 -- Several minor new bugs/misfeatures fixed (and one old one).

 Bug fixed in typing the name of the file being flushed from the filelist
   when the filelist is full.
 The input buffer is now cleared just before E exits to await the user
   typing CONTINUE to retry an ENTER (or LOOKUP or OPEN).
 Bug fixed to checking file for having changed when CONTINUEing after
   file busy when extending file from last page.
 Bug fixed in ⊗XPROTECTION NNN command to actually change protection
   (was no-op for last two weeks).
 Insert mode on non-display in -XNUMBERS mode gives prompt and starting
   line number but no subsequent line numbers.
 Fix to avoid wasted core (1K) at end of upper segment (old bug).

∂ *** A HISTORY OF OLDER E CHANGES IS CONTAINED IN:  E.UPD[UP,DOC]  ***
      All information in E.UPD has been merged into this manual.

INDEX of commands.

Read α as CONTROL, β as META, ⊗ as EITHER CONTROL OR BOTH CONTROL AND META.

Modes:	N=Normal, E=line-Edit, A=Attach
	I=command explicitly affects line-Insert mode
	L=command is a Line editor command,
	S=command takes arg from Search distance.
# stands for any decimal number.

Page  Modes   Command	Meaning

  7   N,A     <form>	Go forward one window among incore text
  7   N,A     ⊗0<form>	Go forward a half window among incore text
  7   N,A     ⊗#<form>	Go forward # windows among incore text
  7   N,A     ⊗<form>	Go forward one window, changing pages if necessary
  9   E,L     α<form>	Move cursor to beginning of line
  6   N	      β<form>	Insert an incore pagemark
  7   N,A     <vt>	Go back one window among incore text
  7   N,A     ⊗0<vt>	Go back a half window among incore text
  7   N,A     ⊗#<vt>	Go back # windows among incore text
  7   N,A     ⊗<vt>	Go back a window, changing pages if necessary
  7   N,A     β<vt>	Go back a window, changing pages if necessary
  7   N,A     <cr>	Move arrow to next line
  9   E			 first close line
  9   E	      α<cr>	Leave LINE-EDIT mode, stay on same line
 11   I			 leave LINE-INSERT mode, stay on same line
 13   N			 position cursor at found string (after find)
  9   N	      β<cr>	Insert <cr>
  9   E  		 first close line
  9   I			 insert <cr> but don't leave LINE-INSERT mode
 11   N,I     αβ<cr>	Enter LINE-INSERT mode and insert a blank line
 11   E,I		 enter LINE-INSERT mode breaking current line at cursor
 11   N,E     ⊗#αβ<cr>	Insert # blank lines
  7   N,A     <bs>	Move arrow up a line
  9   E,L  		 move cursor left a char, erasing if at end of line
  7,9 N,A,E,L α<bs>	Same as <bs> but never erase
  7   N,A     β<bs>	Move arrow up a line
  9   E,L  		 erase char to left
  7   N,A     αβ<bs>	Move arrow up a line (non-display users see ⊗U cmd)
  9   E,L		 repeatedly move cursor to left (as long as held down)
      N,E,L   α<tab>	Go to end of current line
      N,E,I   αβ<tab>	Go to end of current line and enter line insert mode

Page  Modes	Command    Meaning

      N,A	<alt>	Abort command
  9   E			 restore line to original condition
 11   I			 leave LINE-INSERT mode, delete line if empty
 13    		<ESC>I	Terminate multi-page FIND
 14			 terminate multiple substitution
 25    			 terminate macro expansion
  6     		 terminate wait on delayed ⊗V command
 10   N,A,E,S	⊗A	Attach 1 line
 10   N,A,E,S	⊗#⊗A	Attach # lines
 10   N,A,E	⊗+⊗A	Attach 1 more line
 10   A		⊗-⊗A	Attach 1 less line
 10   N,E	⊗-⊗A	Attach line just above current line
  7   N,A  	⊗B	Glitch screen up from Bottom
  7   E  	αβB	Glitch screen up from Bottom
  9   E,L	αB	Move backwards in line editor to next char typed
 10   N,A,E,S	⊗#⊗C	Copy # lines into attach buffer
      N,E	⊗-⊗C	Copy line just above current line
      A		⊗+⊗C	Copy one more line
      A		⊗-⊗C	Copy one less line (i.e., kill last line in attach buffer)
  9   E,L	αD	Delete char (if at end of line, delete CRLF)
  7   N,S	αβD	Delete line
      N,S	⊗#αβD	Delete # lines
      N,S	⊗-αβD	Delete previous line
      N,S	⊗-⊗#αβD Delete # previous lines
  7   N		⊗E	Exit
 10   A		⊗E	Leave ATTACH mode by putting down all attached lines
 13   N,A,E	αF	Find string (delimiters not required)
 13   N,A,E	αβF	Find delimited string
		⊗G	Unused
 32   N,A	αH	Go to previous file in file stack (Home)
 32   N,A	αβH	Go to Nth previous file, where N is current default arg
 32   N,A	⊗0αH	Type out file stack
 32   N,A	⊗0αβH	Type out default arg for αβH command
 32   N,A	⊗#αH	Go to #th previous file
 32   N,A	⊗#αβH	Go to #th previous file and set default arg to #
 32   N,A	⊗-⊗#⊗H	Go to #th previous file and pop # files off top of stack
 32   N,A	⊗+⊗#⊗H	Re-push # files back onto top of stack and go to new top
  9   N,E,L	αI	Enter Insert mode (at end of line, enter LINE-INSERT mode)
  9   N,I	αβI	Enter LINE-INSERT mode and insert a blank line
  9   E,I	αβI	Enter LINE-INSERT mode in current line (new line if at end)

Page  Modes	Command    Meaning

  7   N,A,E	⊗J	Jump the arrow line to the top of the screen
  7   N		⊗-⊗J	Jump the arrow line to the bottom of the screen
  7   N,A,E	⊗0⊗J	Jump the arrow line to the center of the screen
  7   N		⊗#⊗J	Jump the arrow line up # lines
  7   N		⊗-⊗#⊗J	Jump the arrow line down # lines
  9   N,E,L	αK	Kill characters forward up to next char typed
 10   A		αβK	Kill all attached lines
 10   A         ⊗#αβK	Kill # lines at front of attach buffer
  9   E,L	αL	Kill characters backward up to next char typed
  7   N,A	αL	Go to first line of current page
  7   N,A,E	αβL	Go to first line of incore text
  7   N,A,E	⊗#αL	Go to Line # of current page
  7   N,A,E	⊗#αβL	Go to Line # of all incore text
  8   N,A	αM	Go to next Mark
  8   N,A	αβM	Place a Mark on current line
  8   N,A	⊗-αβM	Clear Mark on current line
 32   N,A	αN	Go to previous line in line stack
 32   N,A	αβN	Go to Nth previous line, where N is current default arg
 32   N,A	⊗0αN	Type out line stack
 32   N,A	⊗0αβN	Type out default arg for αβN command
 32   N,A	⊗#αN	Go to #th previous line
 32   N,A	⊗#αβN	Go to #th previous line and set default arg to #
 32   N,A	⊗-⊗#⊗N	Go to #th previous line and pop # lines off top of stack
 32   N,A	⊗+⊗#⊗N	Re-push # lines back onto top of stack and go to new top
 32   N,A	αO	Go to previous page in page stack
 32   N,A	αβO	Go to Nth previous page, where N is current default arg
 32   N,A	⊗0αO	Type out page stack
 32   N,A	⊗0αβO	Type out default arg for αβO command
 32   N,A	⊗#αO	Go to #th previous page
 32   N,A	⊗#αβO	Go to #th previous page and set default arg to #
 32   N,A	⊗-⊗#⊗O	Go to #th previous page and pop # pages off top of stack
 32   N,A	⊗+⊗#⊗O	Re-push # pages back onto top of stack and go to new top
  6   N,A	αP	Go to next Page
  6   N,A	αβP	Go to next Page that is not in core
  6   N,A	⊗-αP	Go to previous Page
  6   N,A	⊗-αβP	Go to previous Page that is not in core
  6   N,A	⊗#αP	Go to Page #
  6   N,A	⊗#αβP	Go to Page #, retaining only it in core
  9   N,E	⊗Q	Copy line above, and enter copy in line-edit mode
  9   N,E,L	αR	Repeat line editor αS or αK or αB or αL cmd
 10   A		αβR	Replace attached lines (put them back where picked up)
  9   N,E,L	αS	Skip to next char typed
		αβS	Unused

Page  Modes	Command    Meaning

  7   N,A	⊗T	Glitch screen down from Top
  7   E  	αβT	Glitch screen down from Top
  9   E,L	αT	Transpose the previous two chars in the line editor
  7   N,A,E  	⊗U	Move arrow Up a line (recommended cmd for non-displays)
  6   N,A,E  	αV	Redraw screen (without clearing)
  6   N,A,E  	αβV	Clear and then redraw screen
  7   N,A,E     ⊗W	Go forward one window among incore text
  7   N,A,E     ⊗0⊗W	Go forward a half window among incore text
      N,A,E     ⊗#⊗W	Go forward # windows among incore text
 19   N,A,E  	⊗X	Enter eXtended command next
 25   N,A,E  	⊗Y	Call current macro
 25   N,A,E  	⊗Z	Call a named macro

 25   N,A,E  	⊗#	(Actually the "#" char) Pass macro call arg to next cmd

 24   N,A,E  	⊗∂	Operate on message with next cmd
 24   N,A,E  	⊗!	Operate on paragraph with next cmd

 15   N,A	⊗ε	Switch to given file in READWRITE mode
 15   N,A	⊗λ	Switch to given file in READONLY mode

Page  Modes	Command    Meaning

 15   N,A,E  	⊗∃	Show names of files in fileswitch list
 13   N,A,E  	⊗*	Repeat last ⊗F or ⊗XFIND command
 13   N,E  	⊗\	Repeat last substitution command

  7   N,A	⊗.	Write out current page (not including attach buffer)
  7   E		αβ.	Write out current page (including current line editor)
 15   N,A	⊗?	Switch to the file E.ALS[UP,DOC]/R
 15   N,A	⊗#⊗?	Go to page # in E.ALS
 15   N,A	⊗+⊗#⊗?	Go to E.ALS, # pages beyond where last left it
 15   N,A	⊗-⊗#⊗?	Go to E.ALS, # pages before where last left it
  7   N,E  	⊗;	Move cursor straight up
  7   N,E  	⊗:	Move cursor straight down
 22   N,E  	⊗(	Find (
 22   N,E  	⊗)	Find matching )
 21   N,E  	⊗↔	Return to place ⊗(, ⊗) or ⊗↔ was given

  7   N,E  	α↑	Move to end of line above
  7   N,E,I	αβ↑	Move to end of line above and enter line insert mode
  7   N,E  	α↓	Move to end of line below
  7   N,E,I	αβ↓	Move to end of line below and enter line insert mode
 17   N,A,S	⊗←	Shift line or attach buffer left by current indent default
 17   N,A,S	⊗#⊗←	Shift # lines left by current indent default
 17   N,A,S	⊗→	Shift line or attach buffer right by current indent default
 17   N,A,S	⊗#⊗→	Shift # lines right by current indent default
  7   N,A,E  	⊗>	Move arrow down 4 lines
  7   N,A,E  	⊗<	Move arrow up 4 lines
  7   N,A,E  	⊗≥	Move arrow down half a screen
  7   N,A,E  	⊗≤	Move arrow up half a screen
  7   N,A,E  	⊗∧	Move arrow to top of screen
  7   N,A,E	⊗0⊗∧	Move arrow to middle of screen
  7   N,A,E  	⊗∨	Move arrow to bottom of screen
  7   N,A,E	⊗0⊗∨	Move arrow to middle of screen

Page  Modes	⊗X Command	 Meaning

 26   N,A,E  	ABORT	    Abort one or more macros levels in progress
 19   N,A	ALIAS	    Change your job's ALIAS
 17   N,A,S	ALIGN	    Align left margins of text
  6   N		APPEND	    Add # following pages to incore text
 26   N		ATTACH	    Place an editable macro definition in the attach buffer
 19   N,A,E  	AUTOBURP    Set or read autoburping threshold
 32   N,A	BACKGO	    Go back to page that you last came from (see ⊗O cmd)
 19   N,A	BEEPME	    Beep the user's terminal now
 12   N,A,S	BREAK	    Break line(s) at given column position
 19   N,A	BURP	    Burp current page of extraneous null records
 19   N,A,E  	CANCEL	    Flush unwritten changes to incore page(s)
 17   N,A,S	CENTER	    Center text of given lines between margins
 19   N,A,E	CHECK	    Enable free storage checking within E
 19   N,A	CLOSE	    Close the file, but allow further editing
 26   N,A,E	COMMENT	    No-op, useful for putting comments in command files
 21   N,A,E	CONTROL     Make next cmd char have only the CONTROL bit
 19   N,A,E  	DDTGO	    Call RAID, if available (ERAID only)
 25   N,A	DEFINE	    Define a macro
 19   N		DELETE	    Delete the next (not-incore) pagemark
 23   N		DIRED	    Swap to the DIRED directory editor
 19   N,A	DPYALWAYS   Update the display after every command
 19   N,A	DPYSKIP     Only update the display when no typeahead
 19   N,A,E  	DRAW	    Update the display now
 23   N		DRD	    Swap to the DIRED directory editor
 19   N,A,E  	EMPTY	    Move to next empty line on page
 21   N,A	ENTER	    Switch to given file in READWRITE mode
 21   N,A	EPSILON     Switch to given file in READWRITE mode
 13   N,A	EXACT	    Distinguish case of letters in searches
 26   N,A,E  	EXECUTE	    Read and execute commands from a file
 21   N,A,E  	EXIST	    Type out fileswitch list

Page  Modes	⊗X Command	 Meaning

 13   N,A,E  	FIND	    Do a multipage search for a given string
 23   N		GORPG	    Swap to SNAIL (RPG) to reexecute last cmd
 19   N,A	HEIGHT	    Set the number of lines of display used by E
 32   N,A	HOME	    Go to relative or absolute page in Home file
 17   N,A,S	INDENT	    Indent lines by given amount
 19   N		INSERT	    Insert an incore pagemark before current line
 16   N,A,S	JFILL	    Justify paragraphs w/out aligning right margin
 16   N,A,S	JGET	    Get justification margins from text
 12   N,A,S	JOIN	    Join two or more lines by deleting CRLFs
 16   N,A,S	JUST	    Justify paragraphs and align at right margin
 21   N,A	LAMBDA	    Switch to given file in READONLY mode
 19   N,A	LINCNT	    Type length of current line, plus more info
 21   N,A	LOOKUP	    Switch to given file in READONLY mode
 22   N,E  	LPAREN	    Search for next "(", crossing page boundaries
 19   N,A	M	    Make the current line start a new page
 19   N,A,S	MAIL	    Mail a message to someone
 19   N,A	MARK	    Make the current line start a new page
 21   N,A,E	METACONTROL Make next cmd char have both META and CONTROL bits
 21   N,A,E  	MSG	    Operate on current message with next command
 30   N		NDFAIL	    Make a New Directory line (FAIL type) for page
 30   N		NDSAIL	    Make a New Directory line (SAIL type) for page
 19   N,A,E  	NONEMPTY    Move to next non-empty line on page
 21   N,A,E	NUMBERS     Enable or disable typing of line numbers with text
 19   N,A	OPEN        Open the current file in Read-Alter mode
 22   N,A,E  	PAREN	    Set the chars searched for by parenthesis cmds
 21   N,A,E  	PARTIAL     Operate on current message with next command
 22   N,A,E  	PINFO	    Type out info about last parenthesis command
 15   N,A	POINTER	    Switch to a file named in the incore text
 19   N,A	PPSET	    Ensure that the page printer is positioned ok
 19   N,A	PROTECTION  Set or read the protection key of the file
 26   N,A,E	PUTDEFS	    Write out all current macro definitions in a cmd file
 19   N,A,E  	QUIT	    Exit to monitor without writing out the file

Page  Modes	⊗X Command	 Meaning

 19   N,A	READONLY    Disallow changing the file
 19   N,A	READWRITE   Allow changing the file
 26   N,A	REDEFINE    Define a macro from incore page or attach buffer
 19   N,A,S	REMIND	    Enter a REMIND-system reminder
 25   N,A,E	RESUME      Resume expansion of a macro that was stopped early
 22   N,E  	RPAREN	    Search for next ")", crossing page boundaries
 23   N,A,E  	RSYS	    Run a given system program, with RPG startup
 23   N,A,E  	RUN	    Run a given user program, with RPG startup
 19   N,A	SAVE	    Write out incore page(s) in E$SAVE.TXT
 19   N,A,S	SEND	    Send a message to someone logged in
 19   N,A,S	SIN	    Replace tabs with equivalent numbers of spaces
 16   N,A,S	SJFILL	    Separate text into justified sentences
 16   N,A,S	SJUST	    Separate into justified right-aligned sentences
 19   N,A,S	SPOOLC	    Spool incore page(s) on the line printer
 25   N,A,E	STOPALL	    Set action on macro error to stop all macros
 25   N,A,E	STOPHOW	    Find out setting of macro error action
 25   N,A,E	STOPONE	    Set action on macro error to stop just one macro
 25   N,A,E	STOPZERO    Set action on macro error to ignore errors
 18   N,A,S	TABLE	    Line up entries in a table
 19   N,A	TELLME	    Send a report of latest commands to ALS
 19   N,A,E  	TERSE	    Enter terse mode--suppresses some typed info
 18   N,A,S	TGET	    Same as TJGET command (see below)
 19   N,A	THISPAGE    Write out incore page(s) and read back only current page
 19   N,A,S	TIN	    Replace multiple spaces with equivalent tabs
 18   N,A,S	TJFILL	    Justify paragraphs that begin with a table
 18   N,A,S	TJGET	    Get margins for TJFILL/TJUST from text
 18   N,A,S	TJUST	    Justify & R-align paragraphs beginning w/table
 19   N,A	TMPCOR	    Write out (now and on exit) TMPCOR file used by E
 23   N,A	TV	    Swap to the TV display editor
 21   N,A,S	TYPE	    Type out line(s) of text
 28   N,A	UPDATE	    Write out the updated incore directory
 19   N,A,E  	VERBOSE     Enter verbose mode--types out extra info
 19   N,A,E  	WRITTEN     Type out who previous wrote the file and when
 19   N,A,S	XSPOOL	    Spool incore page(s) on the XGP
 32   N,A	ZFILES	    Zero (clear) the file stack (and filelist)
 32   N,A	ZLINES	    Zero (clear) the line stack
  8   N,A	ZMARKS	    Zero (clear) all line marks
 32   N,A	ZPAGES	    Zero (clear) the page stack
Abbreviations and explanation of E documentation.  Credits.

This version of the E manual is  intended for on-line use by the  normal
user.  It  may be  referenced at  any time  while editing  another  file
simply by typing a <CONTROL>? command.   One may always return to  one's
original file by typing the <CONTROL>H command.

   A  simplified form of  this manual  for the beginner  is available by
typing HELP ETEACH with a carriage return to the  system.  This copies a
file  named TEACH into  one's file area  and allows  one to read  it and
modify it for practice.

   This is p. 4 of E.ALS[UP,DOC]   (see  the  top line with  asterisks).
Page 1,  the "directory" page,  is automatically prepared  by E,  and in
this case has been planned to be of maximum  help to the user.  There is
also an Index of Commands on p. 3.

ABBREVIATIONS used in this manual and in TEACH to characterize commands.

   α     means hold the "CONTROL" key down while typing a character.
   β     means hold the "META" key down while typing a character.
   αβ    means hold both "CONTROL" and "META" keys down while typing.
   ⊗     means use either α or αβ with the next character.

   Most commands are single characters with one or both of the two keys.

		Additional abbreviations
   <cr>    carriage RETURN key.			<lf>    LINE feed key.
   <tab>   TAB key.				<alt>   ALT-mode key.
   <bs>    Back-Space key.			<form>  FORM-feed key.
   <vt>    the VT key.				<clear>	the CLEAR key.
   CURRENT means the current line (normally with an → or ↔ on the left).


Credits.

   Dan Swinehart wrote TV,  the original  version of the display editor,
and created  the original version of TEACH.   Fred Wright wrote the FAIL
version of  TV  (called E).   Brian  Harvey  modified TEACH  to  reflect
differences  between E  and  TV.   Arthur Samuel  and  Brian Harvey  are
responsible  for this  version.  Address all  comments and  questions to
Samuel, who is currently trying to fix the remaining bugs in E.

Disclaimer.

   An attempt has been made to present a coordinated view of E.  To this
end some simplications have been made.  The experienced user may develop
techniques that are  not described in this  manual.  Any outright errors
should, however, be called to our attention.
General remarks.

    E is a fast display-oriented text  editor for disk files.  By  using
random access to individual  pages, E can move  around quickly within  a
file without having to be continually recopying the file; and only those
pages whose texts are changed are ever written out to the disk.  E keeps
one or more contiguous pages in core and, on display terminals, shows to
the user a portion  of this text  as if through  a window, thus  showing
lines of text  in context  rather than isolated.   Various commands  are
available for moving the window from place to place in the file and  for
moving around within  the window.  (Normally  only one page  is kept  in
core, but the user can cause several contiguous pages to be kept in core
to provide even faster movement among those pages.)  On displays, a line
pointer (arrow) and an underscoring cursor are used to mark the position
in the text where editing is  to occur.  On non-display terminals,  text
is typed out instead of displayed.

    Note: On Datamedia terminals (DMs), no arrow is used to indicate the
current line.  Instead, the  terminal's cursor is  left under the  first
character of the current line.

    The window of text on a  display screen is bordered above and  below
by lines consisting mainly of asterisks  or dots but which also  include
information about the editing.   A top or bottom  border will be  mostly
ASTERISKS  when  the  last  text  line  in  that  direction  is  visible
ON-SCREEN, and the border  line will be mostly  DOTS when there is  more
text OFF-SCREEN in that direction.

    The border line at the top is called the header line, and the border
line at the bottom is called  the trailer line.  The information on  the
header line includes:
	(1) the number of the text line just below the header,
	(2) the number(s) of the incore page(s),
	(3) the name of the file, and
	(4) the editing modes.
The trailer line reports:
	(1) the number of the current line,
	(2) the total number of lines on the current page,
	(3) the number of the current page,
	(4) the total number of pages in the file, and
	(5) some information about the size of the page(s) in core.
This  last item  tells the page's  size with  respect to  the number  of
records that it currently occupies on the disk.  The amount of room  the
page currently uses  on the  disk is given  in records  followed by  the
letter "R".  Following this is a  number that shows how much spare  room
there is for this page on the disk or how much extra room the page needs
in order to write it out to the disk.  The amount of spare room or extra
room needed is reported in characters and is followed by the letter  "C"
provided the number is 640 characters or less.  In this case, a negative
number means there  is that  much room to  spare and  a positive  number
means that much extra room is needed.   If the amount of spare or  extra
room is more than  640 characters, it will  be reported in records  (640
characters/record) and will be  followed either by  the letter "B"  (for
Bloated) if there is room to spare or by the letter "X" (for eXpand)  if
more room is needed.

    If the file is not formatted, only a "?R" will appear where normally
the R and C/B/X fields appear.

    Extra records indicated by a "B"  on the trailer line will never  be
removed automatically,  although  they  can be  removed  by  the  ⊗XBURP
command.

    E does not make a separate disk copy of the file being edited unless
that is requested by the use of a special command (described later),  so
take care--when you write out a  page, the former contents of that  page
are lost.

    Basic editing in E (on displays) utilizes the system line editor for
editing a single line at a time.  E loads text from the current  version
of a text line into the display's line editor and then lets you edit  it
with the usual system line editor commands.  When you are done with  the
line, you type <cr> (or some other command) to give the edited text back
to E.

    E achieves its speed (1) by using the system's line-editor and  only
changing the core copy of the text on the completion of a line edit, and
(2) by updating the disk  copy of the page only  on the completion of  a
page edit (automatically effected by  moving to another page).  You  can
undo an entire page of  incorrectly made modifications by cancelling  an
update, but unfortunately, you can also  lose an entire page of  desired
modifications or additions  if the system  should go down  unexpectedly.

    E is  best understood  by  recognizing that  it  operates in  a  few
different modes and that many  commands are appropriate only to  certain
modes.  In  fact, a  couple  of commands  have quite  different  effects
depending upon the mode  that E is  in at the time  when the command  is
given.

    The dominant mode is the NORMAL mode.  This allows for page,  window
and line pointer movement  commands and commands  which enter the  other
modes.
PAGE CHANGING, APPENDING, DIVIDING and COMBINING: ⊗XAPPEND β<ff> ⊗XMARK ⊗XDELETE

PAGE CHANGING commands.

   PAGE-CHANGING commands are single characters typed with the CONTROL key
held down or with both the CONTROL and the META keys held down.  They may
take modifiers as shown below.  Note: if you have more than one page in
core, then there is a slight difference between the commands αP and αβP.

   αP	    Go to the next Page.
   αβP      Go to the next Page that is not already in core.

   ⊗7αP	    Go to page 7.
   ⊗7αβP    Go to page 7, retaining only it in core.

   ⊗+⊗4αP   Go forward 4 pages.
   ⊗+⊗4αβP  Go forward 4 pages from the last page in core.

   ⊗-αP     Back up to the previous page.
   ⊗-αβP    Back up to the previous page that is not already in core.

   ⊗-⊗3αP   Back up 3 pages.
   ⊗-⊗3⊗P   Back up 3 pages from the first page in core.

   It is good practice to  limit the page size to less than  150  lines.
This eases the load on  the editor and makes the directory  of more use.
The directory will be much more useful if you also make it a practice
to start each page with a suitable comment, in the case of code perhaps
containing a list of all labels to be found on the page.  You can than
use a special search procedure (explained on p. 13) to expedite the 
location of any desired item that is so listed.

   The following commands leave the page unchanged but they refresh the
screen.  If any of these commands is typed ahead, the screen will be
redrawn immediately when the command is encountered, despite any further
type-ahead.

  αV	  Redraw the screen WITHOUT first clearing it (the fastest).

  αβV	  Clear the screen and then redraw it (this is slower on Data Discs).

  ⊗3⊗V	  Redraw screen as above then wait 3 seconds before continuing.
	  <esc>I will terminate the wait.


PAGE APPENDING commands.

It is possible to have more than one page in core at the same time.  This
technique makes it possible for two pages to be edited together at the
same time while retaining all of advantages of short pages, as noted above.
To do this one makes use of the EXTEND command ⊗XAPPEND<cr> command (see
page 19 for full details regarding EXTEND commands).

 ⊗XAPPEND<cr>	Append the next page to the page or pages that are
		currently in core so that the two or more pages may be
		viewed and edited togather.  This command is not legal
		from the directory page or in an unformatted file.


PAGE DIVIDING commands

A page may be split  into two pages in either  of two ways, one way
leaving only the newly created page in core and the second way leaving
both pages in core together.

With either form of the command  the current arrow line becomes the  first
line of the newly created page.  (See the next page for arrow moving.)

    An apparent exception to this occurs if there is an attachment  at
    the time  when  the  command  is issued,  but  in  this  case  the
    attachment is  first  released,  where-upon its  first  line  then
    becomes the  arrow  line and  then  the newly  requested  page  is
    formed.

 ⊗XMARK<cr>	Split the current page into two pages with the arrow line
		as the first line of a new page.  Write out the incore
		pages and retain in core only the page containing the
		previous (and still current) arrow line.

		If this command is given when there is some text attached,
		the attached lines are first put down and then the page is
		divided in two and written out.  The division occurs at
		the beginning of the formerly-attached lines unless those
		lines are already at the top of a page, in which case the
		division occurs after the formerly-attached lines.  The
		arrow is left at the top of the formerly-attached lines,
		whose page is the only one retained in core.


 β<form>	Split the current page into two pages with the arrow line
		as the first line of the newly created page and retain
		both pages in core without writing out anything.

PAGE COMBINING commands

Two pages may be combined into one page in either of two ways.

  ⊗XDELETE<cr>	Delete the pagemark at the end of the last incore page
		and add the text that was formerly on the next page to
		the present in-core page, writing out the resultant page.

To delete a page mark that divides two pages that are already in core
togather, one moves the arrow to the on-screen representation of the
page mark separating the two pages and gives the following command.

  αβD		When this command is given with the arrow pointing to an
		on-screen page mark, the page mark is deleted and the two
		adjoining pages are combined into one page.  Thus, this
		command will delete either regular text lines or pagemark
		lines (without writing out any pages).

WINDOW and ARROW moving commands.

These are Normal-mode commands.  The CURRENT line is marked by an arrow
and is the line that would be processed if one were to enter the line-
editor.  In the descriptions below it will be referred to as the arrow
line.

The first set of commands control the position of the window on the page.
The arrow is usually repositioned by these commands.

 <form>	  Advance the window, that is, move the last line to the top.  This
	  command (without control bits) does not advance the window beyond
	  the range of the in-core text.
	  An argument may be used (typed with control bits and preceding
	  the <form) to define the number of windowfuls to be advanced.
  ⊗W	  This is an older (still functioning) command to do the same thing.

 ⊗4<form> Advance 4 window among the incore text.
 ⊗4⊗W	  Same thing.

 ⊗0<form> Advance half a window.
 ⊗0⊗W	  Same thing.

 αβ<form> Advance the window as defined above but replace the in-core text
	  by the next page if the the end of the in-core text is already
	  within the window.

 β<form>  This command is NOT a window moving command (see page 6  for its
	  explanation).  Do not confuse it with <form> or αβ<form>.

  <vt>	  Move the window up so that the first line becomes the LAST.  This
	  is the reverse of <form>.  This command without control bits does
	  not back up beyond the range of the in-core text.
  
 ⊗3<vt>	  Back up 3 windows among the incore text.

 ⊗0<vt>	  Back up half a window.

 αβ<vt>   Move the window up so that the first line becomes the LAST.  This
  or	  command (with both control bits), will cause the in-core text to be
 β<vt>	  replaced by the next earlier page if the start of the in-core text
	  is already within the window.  If any arg is given, that many
	  windows are backed up, but only among the incore text.

The following commands move the position of the window on the page, leaving
the arrow so that it still points to the same line of the text, if this is
possible, otherwise causing it to point to the first or last line on the
window.

   ⊗J     Move (JUMP) the window so that the arrow line is at the top.
   ⊗0⊗J   Move (JUMP) the window so that the arrow line is at the middle.
   ⊗-⊗J   Move (JUMP) the window so that the arrow line is at the bottom.

   ⊗3⊗J   Move (JUMP) the window so that the arrow line is 3 lines higher
	  in the window (with the top as the limit).
  ⊗-⊗7⊗J  Move (JUMP) the window so that the arrow line is 7 lines lower
	  in the window (with the bottom as the limit).

          Note that  the  default argument  for the  J  commands is,  in
          effect, infinity, with the argument 0 having a special meaning
          rather than being a undefined.

   ⊗T     Glitch the screen so that 4 additional lines are displayed at the
   or	  top (⊗T) or bottom (⊗B) of the screen.  An argument, if used, is
   ⊗B	  in multiples of 4 lines of glitching.  If either of these
	  commands is given from the line editor, then αβ must be used
	  (the α version will be a line editor command instead) and the
	  the arrow is maintained on the same text line, which is not
	  permitted to move beyond the edge of the screen, and you are
	  left still in the line editor.

The following commands move the arrow with respect to the window, without
moving the window.
   ⊗∧	  Move the arrow to the top line in the window.
 ⊗3⊗∧	  Move the arrow to the line that is 3 down from the top of the
	  window.
 ⊗9⊗9⊗∧	  Since this would be off of the window the arrow is simply moved to
	  the bottom of the window.  (The next command does this more easily).
   ⊗∨	  Move the arrow to the bottom line in the window.
 ⊗4⊗∨	  Move the arrow to the line that is 4 up from the bottom of the
	  window.

 ⊗0⊗∧	  Move the arrow to the middle of the window.
 ⊗0⊗∨	  Move the arrow to the middle of the window.


The following commands move the arrow with respect to the text.  Should this
require the arrow to leave the currently displayed window, the window is
shifted, usually so that the arrow line will be in the middle of the window.

   <cr>   Move the arrow down a line, unless at row of stars.
   ⊗>     Move the arrow down 4 lines.
   ⊗≥     Move the arrow down 1/2 screen.

   <bs>   Move the arrow up a line (cannot be typed ahead on non-displays).
   ⊗U     Move the arrow up a line (works better than <bs> on non-displays).
   ⊗<     Move the arrow up 4 lines.
   ⊗≤     move the arrow up 1/2 screen.

   αL	  Move the arrow to the first line of the current page.
   αβL	  Move the arrow to the first line of all the incore text.
  ⊗5αL	  Move the arrow to the 5th line of the current page.
  ⊗5αβL	  Move the arrow to the 5th line of all the incore text.
  ⊗∞αL	  Move the arrow to the end of the current page.
  ⊗∞αβL	  Move the arrow to the end of all the incore text.

The following comands move the arrow with respect to the text, as above,
AND  they enter the LINE-EDIT mode.  They may also be given when in the
LINE-EDIT mode (see p. 9) but they then require αβ with the arguments.

  ⊗↑        Enter the LINE-EDIT mode with the cursor at the end of the
	    previous line.
  ⊗3⊗↑      Enter the LINE-EDIT mode with the cursor at the end of the
	    third previous line.
  ⊗↓        Enter the LINE-EDIT mode with the cursor at the end of the
	    next line.
  ⊗6⊗↓      Enter the LINE-EDIT move with the cursor at the end of the
	    sixth line forward.
   
The following commands remove text lines from the page.

   αβD    DELETE the entire CURRENT line.
	  This takes both α and β since αD has a different meaning.
	  Use with caution, the only way to undo a line deletion is
	  to cancel all corrections to the current page that have
	  been made since the last disk update.

   ⊗4αβD  Delete 4 lines starting with CURRENT.

Two NORMAL-MODE commands that may be used to save an edited page are:

   ⊗.	  Write the current page (as corrected) into the disk file.
	  Note, this is done automatically with a change page command.
   ⊗E     Do a ⊗. and then EXIT to the system.  This is not a legal
	  command to execute during macro expansion because the same
	  command is used to put down any attach buffer (see p. 10).
	  After you exit from E, you can get back into E at the same
	  place by immediately using the system command CONTINUE.

   Most of the NORMAL-MODE commands require the use of the CONTROL key
and perhaps the META key.  <cr>, <vt> and <form> are exceptions.
LINE MARKING commands.

E provides the facility of  marking up to 23  line locations with a  rapid
way to return to these locations  by using the following commands.

Marks are relative with respect to the line locations on the page but  the
stored values are corrected for line and page insertions and deletions  so
that the marks appear to stick  with particular text lines.  However,  the
justification commands and the line-breaking and line-joining commands  do
not adjust marks properly, so those  commands may cause the marks to  move
slightly from the originally marked text lines.

Marks  do not accompany attachments  and they do not disappear when  lines
are deleted.  Instead,  marks on lines  that are attached  or deleted  are
moved to the first remaining line after the attachment or the deletion.

The ⊗XCANCEL command resets the marks for the page being cancelled to  the
values they had when this page was  last saved by an αβ. or page  changing
command.  Incidentally, if all  marks, including those  on other than  the
current page, are removed by an ⊗XZMARKS command, they may all be restored
by the ⊗XCANCEL command, (if this is done before any page saving  command)
with, of course,  the accompanying restoring  of the text  of the  current
page.

Marks are saved during ⊗ε, ⊗λ, ⊗? and ⊗H file-switching operations and are
restored on returning to a previously marked file.

       αβM  Plant a line mark at the current line on the current page.
     ⊗-αβM  Clear the line mark (if any) on the current line.

        αM  Go forward to the next line mark (cyclicly).
      α2αM  Go forward to the second line mark found (cyclically).
      α-αM  Go backward to the first previous line mark (cyclicly).
    α-α3αM  Go backward to the third line mark found (cyclically).

  ⊗XZMARKS  Clear all line marks.
⊗-⊗XZMARKS  Clear all line marks on the current page.
LINE-EDIT commands.

   E uses  the line-editing commands  that are  a part of  the operating
system.  There is a limit (usually 133) to the number of characters that
the line editor can handle.

   Typing a character without a CONTROL or META key will normally invoke
the line editor  and the character  is typed  into the CURRENT  line.  A
cursor will appear  under the first  character in the  line and in  that
position where  the next typed character  will go.  A character so typed
overwrites  the character that was at the  cursor's position.  E will be
in the LINE-EDIT mode.

   A word of caution--it is usually safe to  continue typing on entering
the LINE-EDIT mode without waiting  for the system to catch up.  Most of
the earlier bugs that caused this to fail have been fixed but it is wise
to look before giving a carriage return and if anything is amiss to type
<alt> and start  over again.

   When the  arrow  appears to  point at  the  bottom row  of  asterisks
(which, of course,  is not in the  text) E will accept  anything that is
typed  as an  added line of  text.  The asterisks temporarily  disappear
only to reappear below the  new line on the completion of  the addition,
and E reverts to the NORMAL mode.

   When in the  LINE-EDIT mode a <cr>  will terminate the mode  and move
CURRENT  to the next  line.  A  α<cr> will terminate  the LINE-EDIT mode
without moving  CURRENT.   Remember  that the  line corrections  do  not
appear in the core image until you leave the line-editor mode.

   Also remember that the  version on the disk still does  not show your
corrections  until  a  disk update  has  been  initiated.  When in  this
intermediate state the letter W will appear at the end of the title line
(with asterisks or dots at the top of the window, meaning that something
is yet to be written.

   If your change will require the directory to be changed, this will be
shown by the letter D in this top line.  The letter X can also appear if
the change requires an  extension in the space  on the disk assigned  to
the current page.  The letter X also appears on the trailer line with  a
number specifying the number of extra  records (of 128 words) that  will
be required.  If no extra records are required this X is replaced by the
letter R following a  number specifying the number  of records that  the
page occupies or will occupy on the disk.  After a deletion the letter B
may appear in  place of this  R or X,  again preceded by  a number  that
specifies the number of all-null records that the page will contain.

   By the way, window  moving commands do  not automatically update  the
disk, whereas page changing commands always do an update.

   Most of the line  editing commands listed below  will also enter  the
LINE-EDIT mode from the NORMAL mode,  except when the arrow is  pointing
either at the row of asterisks (at the end of the page) or at an  incore
pagemark.  However, the  following line editor  commands will not  enter
LINE-EDIT mode from  NORMAL mode,  where they  have different  meanings:
αT, αB, αL, α<form>, <bs> and ⊗<bs>.

   If you make a mistake and  perhaps lose some valuable information hit
<alt> rather than <cr> and your data will reappear as if by magic.

The following commands move the cursor without changing the line.

   α<space>   Move the cursor  to the right 1 space.
   α4α<space> Move the cursor 4 spaces  to the  right.
   α<bs>      Move the cursor to  the left  1 space.
.  α5α<bs>    Move the cursor 5 spaces to the left.
   α<tab>     Move the cursor to the end  of the line.
   α<form>    Move the cursor to the start of the line.

   αS then <char>    Move the cursor to the next occurrence of <char>.
   α3αS then <char>  Move the cursor to the 3rd next occurrence of <char>.

   αB then <char>    Move cursor backwards to nearest occurrence of <char>.
		     This command will not enter the line editor from NORMAL
		     mode, where it has a different meaning.
   α3αB then <char>  Move cursor backwards to 3rd nearest occurrence of <char>.

The following commands allow you to insert or delete characters.

  β<char>   Make  room and  insert  <char>  ahead  of the  cursor
	    position.

   αD       DELETE a character and move the rest of the line to the
	    left.  If at the end of the line,  this will append the
	    next line to the current one.  E will prevent this from
	    being done if the resulting line would be too long for
	    the line editor.
  α4αD	    Delete 4 characters starting at the cursor position but do not
	    append the next line should the count exceed the number of
	    remaining characters in the line (unless command is given when
	    cursor is at the end of the line).

  αK<char>  KILL the line starting with the cursor position up to but
	    not including the character typed.  Do nothing if the no
	    such character is found.
  αK<cr>    Kill the rest of the line starting with the cursor position.

  α4αK<char>  KILL the line up to the 4th occurrance of the character.

  αL<char>  KILL BACKWARDS starting with the previous character on back to but
	    not including the character typed.  Do nothing if the no
	    such character is found before the cursor.  This command will
	    not enter the line editor from NORMAL mode, where it has a
	    different meaning.
  αL<cr>    Kill BACKWARDS everything before the current character.

  α4αL<char>  KILL backwards everyting back to the 4th occurrance of the character.

The following command allows you to correct one of the most common typing errors.

  αT	    Reverse the order of the two characters just ahead of the cursor.
	    This command will not enter the line editor from NORMAL mode,
	    where it has a different meaning.

The following commands allow you to leave the LINE-EDIT mode.
  α<cr>     Accept the line, leave LINE-EDIT mode but do not move the arrow.
  <cr>      Accept the line, leave LINE-EDIT mode and  move the arrow down.
  ⊗U   	    Accept the line, leave the line-edit mode and move arrow up
	    one line.

For completeness  the  <cr> and  <bs> commands  are  listed togather  to
remind  you  that they  do  quite different  things  depending  upon the
associated control keys.

  <cr>      Accept the line, leave LINE-EDIT mode and  move arrow down.
  α<cr>     Accept the line, leave LINE-EDIT mode but do not move arrow.
  β<cr>	    Insert a <cr> before the cursor position; leave LINE-EDIT mode
	    but do not leave LINE-INSERT mode.
  αβ<cr>    Break line at cursor and enter Line¬Insert mode with the new
	    empty line between the two segments of the old line.

  <bs>      BACK SPACE, deletes like β<bs> if at the end of the line,
	    otherwise just moves the cursor to the left like α<bs>.
  α<bs>	    Move cursor to the left WITHOUT deleting.
  β<bs>     Delete the character to the left of the cursor position.
  αβ<bs>    Repeatedly move cursor to left (as long as held down).

The following commands allow you to enter or leave the INSERT and the
LINE-INSERT mode.

  αI	    Enter INSERT  mode (like holding META down continuously).
	    Everything that  you type  (including carriage returns)
	    will be inserted until you type another line command.
	    Any LINE-EDIT command will cause one to leave the INSERT
	    mode, for example, the α<space> command.  If you give
	    this command while at the end of a line, you will enter
	    LINE-INSERT mode instead of INSERT mode.
  αβI	    Break line at cursor and enter Line¬Insert mode with the new
	    empty line between the two segments of the old line.
  α<cr>	    Accept the line, leave Insert or Line-insert mode but do not 
	    move arrow.
  <alt>     Restore the line to it original condition and leave the
	    LINE-EDIT mode.  (See p. 11 for its action when in LINE-INSERT mode.)

The following commands allow you to leave the line-edit mode, move to another
line and reenter the line-edit mode, all with one command.

  ⊗↑        Accept the line, then move to the end of the previous line.
  αβ3⊗↑     Accept the line, then move to the end of the third previous
	    line.
  ⊗↓        Accept the line, then move to the end of the next line.
  αβ6⊗↓     Accept the line, then move to the end of the sixth line
	    forward.

  ⊗;        Accept the line, then edit the previous line from the same
            display position as that from which this command was given.
  αβ3⊗;     Accept the line, then edit the third previous line from the same
            display position as that from which this command was given.
  ⊗:        Accept the line, then edit the next line from the same
            display position as that from which this command was given.
  αβ6⊗:     Accept the line, then edit the sixth line forward from the same
            display position as that from which this command was given.


    The above commands work in both NORMAL and LINE-EDIT modes, as does
the following command which allows you to copy a line and then edit it.

  ⊗Q       Insert a copy of the line just above CURRENT and open it
	   for editing (i.e., enter LINE-EDIT mode in new line).

   If you are  editing a line  and type something  that the line  editor
does  not understand it  will usually  ignore the error  (after thinking
about it for a moment) but don't bank on this too heavily because it can
fail.

   If you type a legal ⊗ command (some are forbidden) when in  LINE-EDIT
mode the line will be accepted as edited and the command will be carried
out.
  (Typing ⊗. in LINE-EDIT mode returns to LINE-EDIT mode automatically
without writing the page because this command is illegal in LINE-EDIT mode.)

   The α<cr> command, that works to recall a line from the system buffer
in the system's monitor mode, is replaced by the ⊗Q command as described
above.
Attach and Copy commands: ⊗A ⊗C

   The attach (⊗A)  and copy  (⊗C) commands  permit blocks  of lines  or
copies of them to be moved up and down on the page or from page to page,
or from file to file, as desired.

   The ⊗A command removes one or more contiguous lines of text from  the
core image of the page and places them in a special attach buffer.   The
lines are still displayed on the screen in their original position,  and
an "A" is displayed at  the top of the screen  to indicate that you  are
now in attach mode.

   The ⊗C  command makes  a copy  or one  or more  contiguous lines  and
places the copied lines  in the attach buffer.   An "A" is displayed  at
the top of the screen, indicating that you are now in attach mode.

   Note that if more than  8 lines are attached,  then only the first  4
lines and the last  3 lines are shown  so that one can  see a few  lines
both before and following the attached  lines to be certain as to  their
relationship to the rest of the page.  The attached lines are marked  by
vertical bars (thus |) at the left, except on Datamedias, where they are
indicated by being displayed in  BOLD rather than lightface (this  makes
attached blank lines somewhat hard to detect).

   The apparent position of the attached lines can be made to move up or
down on the  page or  from page to  page with  the usual  CURRENT-moving
commands to prepare for a final command which will deposit the  attached
lined back into the  core image of the  text at the indicated  position.
Perhaps this can  be made  clearer by  remarking that  the CURRENT  line
designation is actually attached  to the line  following the section  of
text that has been removed (although  the → does not appear).  What  one
is actually doing when one appears to be moving the attached lines is to
move CURRENT around and E cleverly always displays the attach buffer  on
the screen just above CURRENT, where it will in fact be put if one gives
the deposit-line command.

Basic commands.

  ⊗A     ATTACH the CURRENT line and mark it with a "|".
  ⊗3⊗A   ATTACH 3 lines starting with CURRENT and mark these with "|'s".
	 If a number greater than 8 is used, (for the 3 in the example),
	 only the first 4 and the last 3 lines are shown.  A row of dots
	 is used to indicate that some attached lines are not shown.

  ⊗E     Deposit the attached lines where displayed and Exit ATTACH mode.
	 Note:   this command has a different meaning when one is NOT in
	 the ATTACH mode (it then means EXIT from E).  Don't stutter when
	 typing it.  Give the system time to react.
  αβR    REPLACE the attached lines in their original location and leave
	 the ATTACH mode.
  αβK    KILL the attached lines (they go away beyond recall) and exit
	 from the ATTACH mode.  Note that αK does not work.
  ⊗4αβK  KILL the first 4 lines in the attach buffer.

	 If you make a practice of using the CONTROL key only, when in
	 the ATTACH mode, (when it works) you will avoid the danger of
	 accidentally killing an attachment, if you mean to hit a J or
	 an L and hit a K instead.

  ⊗C     Make a COPY of the CURRENT line and ATTACH this copy.
	 If there is already something in the ATTACH buffer when this
	 command is given then the entire attachment will be deposited and
	 re-copied.  This provides a convienent method of making 
	 multiple copies of any desired portion of text.
  ⊗5⊗C   Make a COPY of 5 lines starting with CURRENT and ATTACH these.


Relative arguments.

  Relative-argument commands add or remove lines from the end of the
  attach buffer thus:

  ⊗+⊗A    Attach 1 more line beyond those already attached.
  ⊗+⊗3⊗A  Attach 3 more lines beyond those already attached.
  ⊗-⊗A    Detach 1 line from the end of those already attached.
  ⊗-⊗2⊗A  Detach 2 lines from the end of those already attached.

  ⊗+⊗C    Copy 1 more line beyond those already attached.
  ⊗+⊗4⊗C  Copy 4 more lines beyond those already attached.
  ⊗-⊗C    Delete (kill) 1 line from the end of the attached set.
  ⊗-⊗2⊗C  Delete (kill) 2 lines from the end of the attached set.

   If the apparent position of the attached lines have been moved before
these relative-argument commands are given then additions and  deletions
are made in terms of the apparent  new location.  This gets a bit  hairy
in the case of deletions but it is a very useful device for assembling a
set of copied lines from several different places.

   Note that a single attach command is only effective to the end of the
current page, and an attachment is deposited all on the same page.

   A word of  warning,  a hazard  is involved in using ⊗A  to move lines
from page  to page.  The attached lines can be lost if the system should
crash during the interval between the removal of the attached lines from
one page  and the final  updating of the  page to which  they are moved.
This hazard can be  avoided by copying  the lines rather than  attaching
them  and  then  going  back and  deleting  the  original  copy.    This
precaution is  hardly necessary for a  line or two but it  is a wise one
when you are moving large blocks of text.

   Moving lines from page to page takes time, so don't get impatient.

   This is a good place to comment on the RIPPLING report, that you  may
have noticed in the scratch-pad lines at the bottom of the screen.  This
notice appears when a  major rearrangement of  the text between  records
becomes necessary.  This also takes time.
LINE-INSERT mode.

While one can add text at the bottom of a page by simply moving the
CURRENT marker so that it points at the bottom row of asterisks (not the
dots), a special mode is used to insert lines of text at other points.
As a matter of fact it is usually better to enter this special
LINE-INSERT mode if one is to type several lines even when at the end of
a page.  Users on non-displays can only enter text in LINE-INSERT mode.

When in the LINE-INSERT mode, typing a carriage return inserts the text
of that line into the page (in core, not on the disk yet), creates a new
blank line below, and leaves you editing the new blank line.  Each
carriage return in LINE-INSERT mode thus creates a new blank line.
Various commands will get you out of LINE-INSERT mode, usually keeping
the text of the last line inserted.  (The exception is altmode when given
on an empty line in line insert mode -- this deletes the empty line.)

The fact that E is in the LINE-INSERT mode is signalled by a double arrow
(↔) pointing to the current line instead of the usual right arrow (→) and
by an "I" appearing on the header line at the top of the screen.  (On
Datamedias, neither the double arrow nor the right arrow is used.  Only
the terminal's cursor marks the current line and the "I" at the top is
the only indicator of LINE-INSERT mode.)


To enter the LINE-INSERT mode:

 αβ<cr> Given from normal mode (not editing a line), this command enters
	LINE-INSERT mode on a blank line inserted ahead of the current
	line.  Given from the middle of a line, this command will break
	the line where the command was given into two separate lines and
	leave you in line insert mode at the end of the first part.  If
	you were at the end of a line when you gave this command, you will
	enter line insert mode on a new blank line inserted just below.
	In any case, a double arrow (↔) and an "I" at the top will
	indicate that you are in LINE-INSERT mode.

   αβI  This command is the same as αβ<cr> except when given from the
	line editor, in which case it enters line insert mode but leaves
	you editing that line without either breaking it in two or
	inserting a blank line.  The next carriage return will, as
	usual, insert a blank line.

   αI   This command enters line insert mode only when given at the end
	of the line editor (otherwise, this is a line editor command).
	From the end of the line editor, this command is just like αβI
	given from the same place (enters line insert mode on a blank
	line inserted below).


While in LINE-INSERT mode:

  <cr>  Accept the line and move down, inserting another new blank line.

 α<cr>  Accept the line and leave LINE-INSERT mode, staying at the same line.

 β<cr>  Insert a <cr> but stay in line insert mode.

  ⊗U    Leave LINE-INSERT mode and move the arrow back to the line above
	the accepted line.

 <alt>  Leave LINE-INSERT mode without moving the arrow.  If the last line
	inserted is empty, delete it.
Handling very long lines.  ⊗XBREAK ⊗XJOIN

   ⊗XBREAK  will  break  lines  at  any  specified  column  position  by
inserting CRLFs.   The column  position may  be specified  by a  numeric
argument following BREAK; the default BREAK column is originally 80  but
any typed-in column argument overrides this and is sticky.  The  command
takes effect starting with the current line (as marked by the arrow)  or
with the first  line of  the ATTACH buffer  if there  is an  attachment.
Breaks occuring within a  TAB are assumed to  precede the TAB, that  is,
the TAB goes at  the start of the  text on the next  line.  There is  an
exception to this if the break is set  at 8 or less and if a TAB  occurs
at the start of a line, when the  TAB will be placed on the first  line.
The current line position is not changed by this command.

   If ⊗XBREAK is given WITH a preceding numeric argument, then that many
lines are broken (not, however, extending beyond the end of the page  or
attach buffer) and  each line is  broken as many  times as necessary  to
prevent any resulting line from  being longer than the specified  column
argument.

   If ⊗XBREAK is given  WITHOUT a preceding  numeric argument, then  the
current line (or the  first attached line) is  broken ONLY ONCE, at  the
specified (or default) column position.

   The ⊗XJOIN command joins lines without introducing spaces for deleted
CRLFs.  ⊗XJOIN will  take a  preceding numeric  argument specifying  the
number of lines to be joined (default is 2 lines).  ⊗XJOIN takes  effect
at the current line or at the  first line of the ATTACH buffer and  does
not cross page boundaries, or the end of the attach buffer.  The current
line position is not changed by this command.

   Thus ⊗XBREAK and ⊗XJOIN  can be used together  to manipulate, and  to
allow editing of, very long lines  because these commands do not  change
any text  in affected  lines except  for the  deletion or  insertion  of
CRLFs.

SEARCH (or FIND) commands: ⊗F ⊗XFIND ⊗* ⊗XEXACT ⊗F<string>⊗P ⊗F<string>⊗:

   The search can be specified in several different ways:

   1) The search can be for an alphameric string that is separated  from
the rest of the text by non-alphameric  characters or it may be for  any
string regardless  of its  surroundings.  Note  that the  FIND  commands
normally make  no distinction  between  upper and  lower case,  but  the
⊗XEXACT command can be used to force such a distinction.

   ⊗XEXACT<cr>	  Distinguish between upper and lower case in subsequent
		  FIND commands of all kinds.  FIND commands will only
		  find string occurrences whose cases exactly match
		  those given in the search string.
   ⊗-⊗XEXACT<cr>  Do not distinguish between upper and lower case in
		  subsequent FIND commands.  This is the default.
   ⊗0⊗XEXACT<cr>  Report the current condition of case-checking.

For single-page searches the commands are:

   αβFSmith<cr>   Find just plain Smith or smith but not this string in
		  in $smith, in blacksmith or in Smithsonian.  Note that
		  % and _ are accepted as alphamerics.
   αFSmith<cr>    Find smith as an isolated word or as part of a longer
		  string (in blacksmith for example).   The string will
		  be found even where not delimited by non-alphamerics.
   ⊗0⊗F		  Type out the search string used in the last single
		  page search command (⊗F).  No search is done.

   Note that no space is used between the ⊗F and the start of the string.

   For multi-page search commands are:

   αβXFIND Smith<cr> Find a delimited string ("Smith" here).
   αXFIND Smith<cr>  Find the string ("Smith") regardless of surroundings.
   ⊗0⊗XFIND<cr>	     Type out the search string used in the last multiple
		     page search command (⊗XFIND).  No search is done.

   Note that exactly one  space is required  between the command  "FIND"
and the search string.  Commands starting  with the letter ⊗X are EXTEND
commands which permit more  than a single character  to be used for  the
command name, hence the  need for the  space to mark  its end.  In  this
case the  complete  command name  is  FIND,  but, since  there  are,  at
present, no other  commands beginning  with F, only  the F  needs to  be
typed, as αXF Smith<cr>.

   Multi-page searches, made  on files entered  /R, are carried  only as
far as the core directory has been extended.  To search the entire file,
one should first complete  the directory by  switching to the last  page
and then switch back to the desired starting page  for the search.   The
fact that the directory is incomplete is evidenced by the use of the "?"
in the trailer line, in lieu of the usual number, to show the total page
count (thus, "Page 13 of ?").


   The delimited find command (αβF or αβXF) will not find an  occurrence
of the  search string that starts  in column 1 of  the current line, but
the non-delimited command (αF or αXF) will find such an occurrence.

   A string, once specified, is sticky; that is, one need not retype the
string  for   a  repeat  of  the  command.   The  search  string  for  a
within-a-page search is remembered independently from that for an EXTEND
search.  For  a repeat one repeats  the command up to  the string itself
and  then types the desired  termination (a <CR> as  shown above, or any
termination listed below).

   Special repeat  commands exist  which simplify  the repeated  search.
These  are easier  to  use than  the regular  repeat  command, described
above, but only the last executed type of FIND can be repeated.   Two of
the more  commonly used  terminations are  simulated by  using different
control keys with the ⊗* command.

     αβ*   Find the  next occurence of  the string  specified by the
  last FIND  command  (whether a  single page  FIND  or a  multipage
  ⊗XFIND).  Move the line cursor to the found line  but do not enter
  the LINE EDITOR, that is, duplicate a normal FIND command  that is
  terminated  by a  <CR> only.   An  argument may  be used  (such as
  αβ1αβ3αβ*) to find the Nth occurence (the symbol ∞ counts as 510).

     α*    Find the  next occurence of  the string specified  by the
  last FIND  command  (whether a  single page  FIND  or a  multipage
  ⊗XFIND).  Leave the line in the LINE  EDITOR as it would be  for a
  normal FIND command  terminated by a α<CR>.  If there is something
  in the ATTACH buffer, this is interpreted as an αβ* command.   See
  below for method of using an argument.

     ⊗4α*    Find the fourth occurrence of  the string specified  by
  the  last executed  FIND  command  (whether  a single  page  or  a
  multipage  FIND) and position the cursor under the first character
  of the found string (as it would be for a normal FIND command that
  is terminated by a α<CR>).  If this command is given from the line
  editor, the argument must be typed with both control keys  (αβ) to
  force activation of the line editor.

     ⊗0⊗*    Type out the search string used in the last FIND command
  executed, and indicate whether it was a single (⊗F) or multiple page
  (⊗XFIND) command.  No search is done.

   2) The  following special symbols  may be used  in the  search string
with the  meanings noted.  If  these characters  are desired as  ordinary
characters  in the  searched-for string  they must  be preceeded  by the
identity symbol ≡.

  Symbol		Meaning

   ¬		The character that follows must not be in the string at
		this point but any other character will be accepted.
   |		Any delimiter (not one of $_% nor a letter nor a digit).
   ∀		Any character.
   ≡		The character that follows immediately after this symbol
		is not to be treated as a special symbol but it is to be
		included as a character in the searched-for string.  Use
		this to quote any of these special characters.
   ∞		Not at present implemented, but still must be quoted.
   ⊂		Not at present implemented, but still must be quoted.


   3) The action  that is to be  taken on the successful  termination of
the search  is specified by the delimiter  used to terminate the string.
The <cr>, used above,   moves the → to the  found line.  A repeat of  the
Find command,  if given, will start  with this same line,  but after the
found string,, so that multiple occurrences of a string within a line can
be found.

Many of the cursor moving commands and substantially all of the LINE-EDIT
commands may be used as the terminating action-defining delimiter.

Some of the more important action-defining delimiters are:

   <cr>     Move CURRENT to the found line or report failure.

   α<cr>    Terminate, as with <cr>, but  move the cursor until it is
	    under the first character of the string.   Note that this
	    leaves E in the LINE-EDIT mode.  A second FIND command can
	    however be given and the next occurrence will be found.  If
	    a FIND command is terminated with <cr>, a α<cr> will still
	    move the cursor to the string.

   ⊗J       JUMP the line with the found string to the top of the
	    window.

   αβ<cr>   Enter the LINE-INSERT mode with the ↔ at a newly inserted
	    blank line ahead of the found line.

   αP       Make the search over the directory page  and then display
	    the referenced page with the line pointer at the top line.
		Note that one can give this command without having to
 		give an explicit command  to go to the directory page.
		If the search fails the current location is unchanged.

   αβP      Make the search over the directory page  and then display
	    the  referenced page  with the line pointer at the second
	    occurrence of the referenced string (the first will be in
	    the first line of the page).

   ⊗:	    Make the search over the irectory page and then display
	    the referenced page with the line pointer at that line
	    which contains the referenced string as a label (namely,
	    the line where the string is followed by ":", "=" or "←").

   ⊗+αP	    Just like  the command  without the  ⊗+, except that only
   ⊗+αβP    pages after the current one are searched in the irectory.
   ⊗+⊗:	    This is a  very  useful  command  when a string occurs on
	    several  directory  lines  (i.e.,  on  the first  line of
	    several pages).

   ⊗A       ATTACH all lines starting with CURRENT up to and including
	    the line with the specified string.
	    If used with an EXTEND command and if the string is not on
	    the windowed page, the attachment will begin at the top of
	    the page on which the string is found.
	    Attachments do not cross page boundries.

   ⊗C       COPY all lines starting with CURRENT up to and including 
	    the line with the specified string.
	    See ⊗A above for restriction with an EXTEND command.

   αβD	    DELETE all lines beginning with CURRENT up to but not
	    including the line with the specified string.
	    See ⊗A above for EXTEND command restriction.
	    This is a very dangerous command so use it with caution.

   ⊗\       Terminate the searched-for string and prepare to accept a
            substitution string.  The substitution string is then typed
	    in and may be terminated in any one of several ways.   For
	    details see String Substitution Commands on the next page.
	    Note that there is a special repeat command for this case so
	    do not try to use the repeat conventions that are used for
	    simple searches.

   <alt>    Abort the present command and cancel the string specification.

   4) The search can be for the first  occurrence of the specified string
or for the n'th occurrence.

   ⊗3⊗Fsmith<cr>  FIND the 3rd occurrence of SMITH.

   5) The <ESC>I command will terminate any multipage FIND in progress
at the end of the page on which it happens to be searching, and it
will report this page number.

   6) The <ESC>I command will also terminate any multiple substitution
(even the one-page type) after the next substitution is done.
SUBSTITUTION commands: ⊗\

String substitution commands are initiated by first giving a normal FIND
command but using one of the two special string terminating  characters,
⊗\ (back-slash)  or  <lf>  (linefeed).   This is  then followed  by  the
substitution string which,  in turn,  is terminated by  either a  simple
carriage return  (which may  be  preceeded by  an argument,  typed  with
control keys) or by α<CR>.  Note, many of the otherwise acceptable  Find
command terminations are not  meaningful with the substitution  commands
and are not allowed.

Please observe that an  argument before the  initial FIND command  means
find the specified  occurrence before making  the substitution while  an
argument before the  final termination means  make the substitution  the
specified number of times starting  with the initial arrow position  (or
with  the  initially  specified  occurrence, if  there  is  an   initial
argument).

The prefered method for making  repeated substitutions is to request  an
initial single substitution and  then to ask  for the desired  remaining
substitutions by the αβ\ command prefaced by an argument specifying  the
remaining number of times the substitution is to be made.

Characters in the searched-for string that are preceeded by the  special
control symbols ¬ and ≡ and  all characters that are represented by  the
special symbol ∀ or by  the symbol | (see p.  13 for the explanation  of
these symbols) are treated  as any other character  and are deleted  and
replaced by the substitution  string.  The "partial definition  feature"
as implemented in SOS is not at present available.  The | symbol in  the
searched-for string can not be used to replace a carriage return.

   Note:  The  FIND command does not find  the very first  delimited
   string on the  line to which the cursor is pointing (unless it is
   in fact preceeded  by delimiter).  This limitation  is of  little
   consequence for  the simple FIND  but it  is an annoyance  if one
   wants  to replace  all occurrences of a symbol  (or string) which
   happens to be the very  first symbol (or string) on a page.   One
   can introduce  an initial  space into the  first line or  one can
   introduce an initial blank line  temporarily and have the  cursor
   at this line.   The space or line  can then be removed  after the
   substitution.

In the rest  of this write-up  "all occurrences" means  "all except  the
very first  character or  string on  the  line to  which the  cursor  is
pointing at the time that the  command is given when the search  request
is for a delimited string".

Also, the remaining descriptions assume that the ⊗XEXACT command has NOT
been given.  If ⊗XEXACT has been given, then substitutions will be  made
only for occurrences with the Exact case of letters given in the  search
string.

Sample commands.

  αβFSTRINGαβ\"String"<CR>	Find the first occurrence of  the
		string STRING, whether  typed in  lower or  upper
		case letters and replace  it by the  substitution
		string as typed, that is, enclosed in quotes  and
		with the initial letter only in CAPS.  Limit  the
		search to the current page starting at the cursor
		location.

 αβFSTRING<LF>"String"<CR>	Same  as  the above  example, but
		typeable on a non-display because of the linefeed
		that is used  instead of  αβ\ to  end the  search
		string.

 αβFSTRINGαβ\"String"αβ∞<CR>	Find  all  occurrences   of   the
		string STRING, whether  typed in  lower or  upper
		case letters and replace them by the substitution
		string as typed, that is, enclosed in quotes  and
		with the initial letter only in CAPS.  Limit  the
		search to the current page starting at th  cursor
		location.

⊗9αβFSTRINGαβ\"String"αβ∞<CR>	Find  all  occurrences   of   the
		string  STRING,   as   above,   but   start   the
		substitution with the 9th occurrence.

   αXFIND ←αβ\ <BACK ARROW> α<CR>	Find the first occurrence
                of the character  ←  whether on the  current page
                or a subsquent one and  replace it  by the string
                <BACK ARROW>  (including  the <  and >) and  with
                spaces   introduced   before  and   after   these
                characters.    Leave  the resulting  line  in the
                line editor.

The <CR> termination is the faster mode of operation in that it does not
use the  the  line  editor  and  it is  not  subject  to  any  effective
limitation as to  the length of  lines that may  be handled.  This  mode
does have one defect  in that the substitution  is completed and is  not
subject to the simple <ALT> method of aborting a single line correction.
When the α<CR> termination is used the substitution is made via the line
editor and the results are left in the line editor's buffer so that  the
substitution may still be aborted by the usual <ALT> command.

The usual rules apply to  the specification of the searched-for  string.
The substitution string may, however, contain certain delimiters (spaces
in particular) whether or not the search is for a delimited string and a
distinction is  made between  upper and  lower case  letters.  Only  the
searched-for  characters  without  delimiters   are  replaced.   To   be
specific,  if  one  were  to  replace  a  delimited  string  by  a  null
substitution string, the  two delimiters would  remain in the  corrected
text.

Currently, substitution cannot be done for the CR (or LF) at the end  of
any line of text.   A warning message  will be isssued  when you try  to
make such  a  substitution.   Also,  no substitution  can  be  done  for
pagemarks (formfeeds).

The substitution string is sticky, so that a substitution  command, when
successfully executed  for a single occurrence, may be repeated  for the
next  occurence by typing αβ\ only.  The typing of  a new string for the
searched-for  string  destroys  the  record  of   the  previously  saved
substitution string  and the entire request must  be retyped before this
command will be honored.

A  null  substitution   string  may  be  used  and  no  longer  reguires
confirmation.

Multi-page substitutions  are useful  but potentially  dangerous as  the
substitutions made on  any one page are, of course, written out onto the
disk file when ever a new page is entered.

As noted earlier,  typing αβ\  after a legal  substitution command  will
repeat the substitution.  This command  may be preceeded by an  argument
(with control bits) and the substitution will be repeated the  specified
number of times.  Should substitutions occur on more than one page,  all
substitutions on pages earlier than the last page will have been written
out.

The use of the  command α\ rather  than αβ\ is also  allowed but is  not
recommended.  This leaves the altered line  in the line buffer with  the
possibility of an <ALT> abort.

Sample repeat commands.

   αβ\		Repeat  the previously made substitution  at the next
		occurrence  of  the  searched-for  string  using  the
		faster and  safer  mode  which  does  not  leave  the
		results in the line editor buffer.

   αβ6αβ\	Repeat the substitution for the next 6 occurrences.

   α\		Repeat the substitution once but leave the results in
		the line editor buffer.

   ⊗0⊗\		Type out the search and substitute strings last used
		in a substitute command, and indicate whether it was
		a single or multiple page substitute command.

The <ESC>I command will terminate any multiple substitution (even the
one-page type) after the next substitution is done.
FILE-SWITCHING and text transfering commands: ⊗ε ⊗λ ⊗∃ ⊗? ⊗XPOINTER

   The file switching commands  ⊗ε and ⊗λ cause  E to close the  current
file being edited (writing out the  current page if necessary) and  then
to ask for the name of another  file to be edited.  That file is  opened
for editing, with  any ATTACH buffer  maintained while switching  files.
Thus you can switch back and forth, editing different files, and  easily
moving or copying text from one file to another simply by attaching  the
lines desired.  The ε command (ENTER)  opens the new file in  read-write
mode while the λ command (LOOK) opens the file in read-only mode.

   All of the  usual switches may  follow the filename typed  with these
commands; for example, you  can use /8P to go to page 8 in the new file,
/E to go to the end of the file, /N to open the new file in no-directory
mode, /C to create  the file you want to switch to, etc.  See  p. 20 for
more details.

   As different files  are referenced,  each file is  assigned a  number
which can be used  thereafter as an  argument to the ε  or λ command  to
call the desired file without retyping its name.  Also, a stack is  kept
of the files you have been in recently and you can return to a file that
is a particular  distance down in  the stack.   See p. 32  for the  file
stack manipulation  command ⊗H.   Whenever  you return  to a  file,  any
previously existing line  marks and  the top  part of  that file's  page
stack are restored.

   The names of up to eight different files edited are remembered by  E.
When you try  to edit a  9th file, the  file at the  bottom of the  file
stack is forgotten to make  room for the new  file's name.  The user  is
warned of this replacement.

   The list of files with their referencing numbers is typed out by  the
command ⊗∃.  The command ⊗0αH types out the file stack.

   Finally it is possible to reference the E-manual file, E.ALS[UP,DOC],
by typing the ⊗? command.  The first reference to this manual will be to
page 2  which  contains  information  on recently  made  changes  to  E.
Thereafter the manual  file is opened  at the last  referenced page  and
line.  One  may, however,  override these  default values  by typing  an
absolute or relative argument to specify the absolute or relative number
of the page to go to.

   E is smart enough  to detect most  cases when one  tries to format  a
binary file  or an  XGP file  and it  will tell  you this  and give  you
another chance to  say No.

⊗ε<file name><cr>   Close the current file  and open the specified
        file in read-write mode.   The usual switches /#P, /#L and
        /C may be used.The new file is assigned a serial number by
	which it  may  be  called later.   (The  initial  file  is
	numbered  0).   When  called  by  number  the  display  is
	returned to the last referenced page and with the arrow on
	the last referenced line and all previously set line marks
	restored.

⊗3⊗ε    Reopen the file assigned the serial mumber 3 in read-write
        mode.  Note that no carriage return is used in this case.
	Return the display to the last referenced page.  Return the
	arrow to the last referenced line and restore all previous
	line marks.  (Use the ⊗∃ command, below, to find numbers).

⊗λ<file name><cr>  Close the current  file and open  the specified
        file in read-only  mode.  The  usual switches /#P  and /#L
        may be used.   The new file is assigned a serial number by
        which it  may  be  called  later.   (The  initial  file is
        numbered 0).

αβ3⊗λ   Reopen the file assigned the serial mumber 3 in  read-only
	mode.

⊗∃      List the previously referenced files with their serial
	numbers.  For convenience the letter H accompanies the number
	in the listing of the "HOME" file and a "]" is used rather
	than a ")" for the file currently being edited.

⊗XZFILES<cr>  Move the current-file listing to location zero and clear
	the remainder of the filelist.  Clear the file stack.

αH      Return (Home) to the last referenced file.  The E-manual
	file is never considered a home file.

⊗?      Close the  current   file  and  open  the  E  manual file
	E.ALS[UP,DOC]  on page 2,(for changes) or, if it has been
	referenced earlier, to the last referenced page and line.
	page and line.

⊗1⊗?	Close the  current   file  and  open  the  E  manual file
	E.ALS[UP,DOC]  on page 1, the directory page.

⊗8⊗?	Close the  current   file  and  open  the  E  manual file
	E.ALS[UP,DOC]  on page 8.

⊗-⊗2⊗?  Close the current  file  and  open  the  E  manual file
	E.ALS[UP,DOC] at 2 pages before the previously referenced
	page.


SWITCHING TO A FILE NAMED IN THE TEXT:

The ⊗XPOINTER command is used to switch to a file whose name is found in
the text of the page you are editing, at or below the current line.
With an argument of zero, the command ⊗0⊗XPOINTER will merely move to
the line containing the filename found (if any) and type out the
filename, but will not switch files.  The command with no argument moves
the arrow to the line containing the filename found (if any) before
attempting to switch files.

Furthermore, a numeric argument can be given to the ⊗XPOINTER command to
have it find the nth filename in the text; thus it is possible to switch
to any of several files all named on a given line.  An arg of the form ⊗#
will make E merely type out the #th filename, without moving the arrow and
without switching files.  An arg of the form ⊗+⊗# means switch to the #th
file named in the text; this is conveniently done right after the ⊗# form
has verified that the filename found was the one you wanted to switch to.
Since ⊗# doesn't normally move the arrow (so that you can then say ⊗+⊗#
without having changed the significance of the number), an arg of the form
⊗-⊗# finds the #th filename and moves the arrow to that line but doesn't
switch files.

Summary of meanings of ⊗XPOINTER args:

  Arg	Meaning

 (none)	Switch to first file named in the text at or below current line.
   ⊗0	Type out the first filename in the text, and move to its line.
  ⊗-⊗#	Type out the #th filename in the text, and move to its line.
   ⊗#	Type out the #th filename in the text (without moving).
  ⊗+⊗#	Switch to the #th file named in the text.


A filename in the text will not be recognized unless it is preceded by a
space (or tab) or occurs at the beginning of a line.  Furthermore, to be
accepted by this command, a filename must have at least one of these:
(1) an explicit (non-null) extension, (2) an explicit (complete) PPN,
(3) one or more switches, or (4) a valid filehack.  Spaces are permitted
only as leading spaces in PPNs for blank characters in the project or
programmer name, and a filename with its switches must occur all on one
line.  Finally, a filename of less than four characters (like "A.I" or
"F/X") will not be recognized by E unless it contains a filehack (which
can be any length).  Thus the following filenames will be recognized:

FILE/-R, FILE.E, FILE[J,G], FILE.EXT[J,G](R9P7L), FILE.[ J, G], \GRIPES.

The following will NOT be accepted: FILE., FILE[X], FILE/6PR, F[ ABC,D].
The only characters permitted in names within the filename are letters
(case of letters is ignored), digits, and the underbar character (which
represents a quoted space).  In particular, the down-arrow construction,
the partial-sign name, and the question-mark name are not permitted in
filenames.

Any switches following a filename in the text will be observed in
switching to that file.  In addition, any text following the extended
command name will be appended to the filename after any switches found in
the text.  Thus additional (or overriding) switches can be specified, or
if no PPN or switches appear in the text, an explicit PPN can be added.
(If the text says READ NOTICE/231P, you can use ⊗XPOINTER/D to get the
READ facility into a switch.)  Switches in the text must be perfectly
well-formed or the filename they are applied to will not be recognized.
This means that parentheses must be balanced and no letter or digit can
immediately follow the letter of a slash-type switch.  However, the
actual letters of switches are not checked for validity (as indeed they
never are by E -- undefined switches are completely ignored).

This command's default mode for switching to a file is readonly (/R).
However, this can be overriden with an explicit /-R occurring among the
switches in the text or typed in the command line after the extended
command name (e.g., ⊗XPOINTER /-R<cr>).

When you attempt to switch files with this command, if the file named in
the text cannot be edited because it does not exist, is busy, etc., E will
abort the fileswitching operation automatically (nevertheless having
written out the current page before attempting to switch files).  If,
however, the combined (text and command line) filename with switches has
an illegal syntax, E will say so and then load your line editor (on
displays) with the combined text so that you can correct it and try again.

Justification: ⊗XJFILL ⊗XJUST ⊗XJGET ⊗XSJFILL ⊗XSJUST
    (See p. 17 for ⊗XTJUST ⊗XTJFILL ⊗XTABLE and ⊗XTJGET)
    (See p. 18 for ⊗XALIGN, ⊗XINDENT, ⊗XJCENTER)


TEXT JUSTIFICATION

E has several justification commands.  The basic commands are ⊗XJFILL
and ⊗XJUST -- the former fills lines as much as possible without
inserting extra spaces, and the latter justifies the right margin by
inserting extra spaces where needed.  The commands ⊗XSJFILL and ⊗XSJUST
are similar but make each Sentence start on a new line.  The command
⊗XJGET is useful for setting up the margins from already-justified text
on the page.  These commands (JFILL, JUST, SJFILL, SJUST, JGET) all use
the same set of margins.  The commands ⊗XTJFILL, ⊗XTJUST and ⊗XTJGET can
do the same things as the same commands without the leading "T" in the
name, but the "T" commands use a different set of margins (so you can
have two sets of margins in effect at a given time) and they are
designed to handle a special form of paragraph -- one that has zero or
more "Tab fields" preceding the text in the first line of each
paragraph.  The "T" commands can align these tab fields and
simultaneously justify the remaining text of each paragraph.  The "T"
commands are described on p. 17.

The range of application of any justification command may be limited by
a prefixed decimal argument.  If no argument is specified, the command
affects the entire page.  If there is an attachment, the command works
on the ATTACH buffer instead of the page.  When the range is limited by
a positive argument, the command starts with the arrow line and goes
forward whereas for a negative argument the command works on the
specified number of lines before (but not including) the arrow line.

There is no effective limit to the length of lines or the margins that
can be handled by the justication commands.

If you're not sure what a justification command will do, you should
execute the ⊗. command to write out the page before the justification so
that you can undo any undesired effect with the ⊗XCANCEL command.


BASIC JUSTIFYING COMMANDS: ⊗XJFILL and ⊗XJUST

The line filling command ⊗XJFILL adjusts the lengths of lines by moving
words from line to line as required to achieve the specified maximum
line length (right margin).  At the same time this command permits the
left margin to be fixed at any desired position with a separate settable
indentation for the first line of each paragraph (crown margin), and it
allows one either to preserve blank lines or to specify the desired
number of blank lines preceding each paragraph (blanklines margin).  The
⊗XJUST command does the same things as the ⊗XJFILL command but also
justifies the right margin by distributing additional spaces between
words.  Both of these commands put two spaces after each sentence that
is terminated by any of the characters ".?!:", provided that two spaces
(or a CRLF) originally followed the sentence.


SETTING THE MARGINS

The margins can be changed by giving a justification command and
following the command name with a space and then the desired new
margins, separated by commas.  The margins are always given in the
same order, namely, Crown, Left, Right, Blanklines.  Any margin that
is not being changed can be omitted but its comma must appear if any
subsequent margins are being specified.  Any margins set remain in
force until explicitly changed.  The meanings of the various margins
are explained below.

  The Crown margin is the indentation used for the first line (crown
  line) of each paragraph.

  The Left margin is the indentation used for all non-crown lines.

  The Right margin is the maximum length of a line, including any
  indentation.

  The Blanklines margin is the number of blank lines desired ahead of
  each paragraph -- setting this margin to -1 will cause E to
  preserve exactly the number of blank lines found in the text.

The margins are initially set to 0,0,74,-1 (C,L,R,B).  This means that
the crown margin (paragraph indent) is 0, the left margin (non-crown
indent) is 0, the rightmost character is not to go beyond column 74, and
the distribution of blank lines is to be the same in the resulting text
as found in the original text.

To find out the current margins, use an argument of zero with a
justification command, for example ⊗0⊗XJFILL<cr>.  A zero argument is
alwo useful for setting the margins without doing any justification.


DETECTING PARAGRAPHS IN INPUT TEXT

A simple procedure is used to determine where paragraph breaks occur in
the input text being justified.  For justification purposes, a new
paragraph is indicated by (1) an empty line or (2) a line indented
exactly the right amount (that is, a line having the right number of
leading blank columns, whether tabs or spaces or both are used to make
the indentation).

The amount of indentation that indicates a paragraph in the input text
will be called the DETECT-PARAGRAPH margin, or simply the DETECT margin.
Note: If you haven't set the detect margin explicitly (see below), and
if the crown margin and the left margin are the same, then only blank
lines will indicate new paragraphs in the input text (otherwise every
line would become a separate paragraph).

The detect margin is normally the same as the crown margin.  However,
for changing the crown margin of justified text that has no blank lines
between paragraphs, the detect margin can be set explicitly to any
value.  The detect margin can be set in any justification command by
typing its value immediately after the extended command name and
following it with a slash ("/").  After the slash, the normal margins
(crown, left, right, blanklines) can be specified, separated by commas.
For instance, the command ⊗XJUST 8/7<cr> would set the detect margin to
8 (for paragraphs indented with one tab or eight spaces) and then would
rejustify the text so that each paragraph was indented only 7 spaces.
Note that the detect margin remains in effect until you change either
the crown margin, the left margin, or the detect margin itself.  Thus
after the above command, E would no longer recognize the new crown lines
(now indented 7 spaces) as such since the detect margin would still be
8.  The detect margin can be set without changing any of the other
margins, as in ⊗XJUST 7/<cr>.  The command ⊗XJUST 8<cr> explicitly sets
the crown margin to 8 and implicitly also sets the detect margin to the
same value (8).


SEPARATING SENTENCES WITHIN PARAGRAPHS: ⊗XSJFILL and ⊗XSJUST

The task of rearranging sentences within a paragraph or of moving
sentences from one paragraph to another is simplified by the use of the
⊗XSJFILL and ⊗XSJUST commands.  These commands separate all sentences in
the specified text so that each sentence starts on a different line.
The first sentence in each paragraph will be indented by the crown
margin and all other sentences will be indented by the left margin.
Within each sentence, the text is justified exactly as it would be by
the ⊗XJFILL and ⊗XJUST commands.  These commands accept new margins
following the command name just like the other justification commands.


FIGURING OUT JUSTIFICATION MARGINS FROM TEXT ON THE PAGE: ⊗XJGET

The ⊗XJGET command causes E to scan a specified section of text and to
determine the indents of crown lines and non-crown lines and the column
position of the rightmost character.  This command sets these values
into the crown margin, left margin and right margin for subsequent use
by the ⊗XJUST, ⊗XJFILL, ⊗XSJUST and ⊗XSJFILL commands.  ⊗XJGET normally
sets the blank-line parameter to its initial default value of -1 (which
means that all blank lines encountered during justification will be
preserved and no new blank lines will be generated).  However, any
margins given explicitly in the ⊗XJGET command will override the
corresponding margins determined from the text.  This command types out
the resultant settings of the margins.

By using this command one can redetermine the parameters that were used
when the text was justified, presumably at some earlier editing session
or perhaps by someone else and one can do this without having to make
the determination by visual inspection.

Here is the algorithm used by E to determine the margins from the text.
First, the length (in columns, not characters) of the longest line in
the range becomes the right margin.  Second, the text is scanned to find
the first blank line.  If a blank line is found, then the next non-blank
line is assumed to be a crown line and its indent is stored as the crown
margin; the indent of the following line is stored as the left margin.
If no blank lines are found within the specified text, then the indents
of the first two lines are compared.  If these two indents are not the
same, the first is taken as the crown margin and the second as the left
margin.  If the first two line indents are the same, these lines are
taken to be non-crown lines and the rest of the text is scanned for the
first line with a different indent; if one is found its indent becomes
the crown margin and the next line's indent becomes the left margin.  If
all lines in the range have the same indentation, then that indentation
becomes both the crown margin and the left margin.  The practical effect
of all of this is that one should not execute a ⊗XJGET command starting
with a line that is the last line of a paragraph (but even that is ok if
a blank line follows).


SOME TYPICAL JUSTIFICATION COMMANDS:

⊗XJUST<cr>     	Justify the current page (or the ATTACH buffer if in
		ATTACH mode) using the current margins.  The right
		margin will be justified.

⊗XJU 0,4,66,0<cr>  Justify the current page or the ATTACH buffer using
		the new margins given.  The crown lines will all have a
		0 indent, the left indent for the rest of the text will
		be 4, the last occupied column will be 66, and there are
		to be no blank lines between paragraphs.

⊗XJFILL 8/10,10,,1<cr>  Justify (left margin only) the current page,
		which has been previously edited so that each paragraph
		starts with 8 spaces (or a tab).  Note that this command
		calls for the indents of all lines (crown and non-crown)
		to become the same (10) and that paragraphs are now to
		be separated by single blank lines.  The right margin is
		unchanged since no new value was given for it.

⊗0⊗XJF ,,72<cr> Change the right margin to 72 and then type out the
		margins, including the detect margin if applicable.

⊗XJGET 4<cr>	Set the margins to those found by examining the entire
		incore text, then set the crown margin to 4, and finally
		type out the new margins.

⊗!⊗XJG<cr>	Set the margins to those found by examining the current
		set of contiguous non-empty lines (⊗! command).  This is
		a very useful command to execute before rejustifying an
		edited paragraph.  However, the ⊗! command is only
		useful for this if you have blank lines between
		paragraphs.  Also, the ⊗! command is not useful as an
		argument to justify commands when you have text
		attached, since the ⊗! command always counts lines on
		the page itself, never in the attach buffer.

⊗6⊗XJG<cr>	Set the margins to those found in the 6 lines starting
		at the arrow (or at the beginning of the attach buffer,
		if any).

⊗!⊗XSJFILL<cr>	Separate the sentences in the current set of contiguous
		non-empty lines (⊗! command).
Commands for tabular material: ⊗XTABLE ⊗XTJFILL ⊗XTJUST ⊗XTJGET
	(See p. 16 for basic justification information and other commands.)

    Four new commands have  been added that permit  one to handle  tabular
material in a manner analogous to way in which normal text can be treated.

    Two types of commands are provided to take care of the two classes  of
input data that are most apt to be encountered, these being:

A)  Tabular material that is in proper columnar alignment but that may have
    missing entries.

    The ⊗XTABLE command is intended for use with such material.

B)  Tabular material that  may not  be in proper  columnar alignment,  but
    where the  entries are  separated by  at least  2 spaces  or by  TABs.
    There may also be normal text associated with each tabular line  which
    is to be justified.  Of course, in  this case there can be no  missing
    entries.

    The ⊗XTJFILL and ⊗XTJUST commands  are intended  for use  under  these
conditions.

   These new Tabular  commands require the  specification of  additional
values in addition to the P,L,R,B  values specified with the ⊗XJUST  and
⊗XJFILL commands.  Of course, just as for these older commands,  default
values may be used and only those values that are to be changed need  to
be specified.  Margins are specified  as usual.

   When new tabular-field values are to be typed, these must start  with
a semicolon ";"  and they  are to be  separated by  commas.  Values  not
otherwise marked  are taken  to be  field lengths,  that is  the  string
;5,8,9<CR> is taken to mean that there are to be three columns the first
one starting with an indent as specified by the P value and with a field
length of 5  character positions,  this is to  be followed  by a  second
field of  8 character  positions, then  one with  a field  length of  9.
These values  supercede  the  field lengths  that  had  previously  been
specified for the first three fields and if still additional fields  had
been specified these are to be retained and shifted to the right or left
as may be required because of the changes to the first three fields.

   When specifying  changes in  fields,  it is  only necessary  to  type
numbers for  those  fields  that  are to  be  changed  and  to  indicate
preceding fields  by  commas.  Fields  after  those typed  are  retained
unless the  typed-in string  is followed  by the  letter Z  (for  zero).
Should there be more fields specified for output than are specified  for
input, E warns  the user at  the time of  execution of the  TABLE or  TJ
command and  ignores the  extra  fields; should  there be  fewer  output
fields than input fields, the command is aborted.

   When several fields are to have  the same length these fields may  be
specified by the use of the @  sign, thus 9@5,7 means that there are  to
be 9 fields of length 5 followed by a field of length 7.  Fields to  the
left of a field that  is to be changed may  be indicated that are to  be
left the skipped by  the use of commas  without numbers, thus ,,7  means
leave the  first two  columns unchanged  and make  the next  one with  a
length of  7.   Similarly  4@0,3@5  means  leave  the  first  4  columns
unchanged and make  the next  3 columns with  lengths of  5.  Note  that
zero, in this case, does not mean  a column of zero length but means  no
change.

   Fields must have widths of 3 or more to permit a single character and
to allow for there to be two spaces between the characters in  different
columns.  Should  any  particular  entry  be  too  long  for  the  width
specified, the next entry is automatically  moved to the right so as  to
preserve the  desired separation  between  columns.  Such  excesses  may
propagate.

   A fourth  command  ⊗XTJGET has  been  provided to  perform  the  same
function for tabular material that is performed for ordinary text by the
⊗XJGET command.  It should be noted that this command must determine the
positions of each column as well as  the left margins and so it must  be
given when the  designated text is  restricted to start  with a  tabular
line in which there are no missing entries.

Note: The ⊗XTGET command does the same thing as ⊗XTJGET.
	

The specifications for these new tabular commands will be listed below.


⊗XTABLE 

This command must be given either 1) after a prior execution of the
⊗XTJGET command, 2) with the entire set of tab fields specified, or 3)
after some combination of commands satisfying 1 or 2.  In effect, one
must provide E with information as to the existing state of the input
textual material since there does not exist any "Normal" set of
conditions that can be assumed.  While, in principle, it is possible to
provide this information by typing it in, it is thought that this task
can best be handled by E with ⊗XTJGET.

   Information regarding the  desired new format  must also be  provided
and this will  usually be  done by typing  the needed  information as  a
suffixed string as described below.   This information is sticky and  it
need not be retyped.  If there  exists a sample of tabular material that
is already in the desired format even this second task may be left to  E
by again using the  ⊗XTJGET command as explained  below.  Note that  the
⊗XTJGET command changes the parameters as they relate to the  conditions
to be established.

   This command will  accept a  prefix argument defining  the number  of
lines to be  processed and  a series  of suffixed  arguments similar  in
every respect to  the syntax used  with ⊗XFILL and  ⊗XJUST.  One  enters
information as to the desired tabular fields by then typing a  semicolon
";" followed  by a  series of  decimal numbers  which define  the  field
lengths to be used.  If several fields are to be all the same length the
syntax, 5@7 for example, may be used meaning in this case that there are
to be  5 fields  of  7 characters  positions  each.  Alternately  it  is
possible to define a field in terms of the last colmnar position that it
is to occupy by prefacing the number with an exclamation mark "!".  Note
that it is not possible to specify the starting column as this is set by
the cumulative lengths of the preceding fields.

   For example, the command  αβ7αβXTAble 4;10,6@5,!60<CR> would  specify
that there be 8 fields with the first one occupying 10 columns  starting
at an indent of 4 then there are to be 6 fields each occuping 7  columns
and a final  field ending at  column 60.  The  starting indent for  this
last field is obtainable by adding up the columns already accounted  for
(44) and so the last  field is to be 16  columns wide.  Note that it  is
only necessary to  type a  single number  before the  semicolon as  this
commands starts all lines with the  crown or new paragraph indent.   The
normal left  margin indent  is not  used and  the program  automatically
determines the right margin value from the accumulated column count.

   This command requires information  as to the  existing format of  the
data to be  reformatted and information  as to the  desired new  format.
The new format information  can then be typed in with  the
⊗XTABLE command or  it my also  be obtained from  an existing table  (or
portion of a table) that is already  in the desired format by using  the
⊗XTJGET command.


⊗XTJFILL and ⊗XTJUST

   As mentioned earlier  these commands  are for use  with tabular  data
that have no missing entries but do have with them some associated  text
that one wants justified.  The  listings of commands with  explanations,
as used in  this manual is  an example of  such material.  The  original
material need not be aligned into columns.

   The methods for specifying the  various parameters is similar in  all
respects to that described for the ⊗XTABLE command.  Especial care  must
be used in  establishing these  parameters particularly  as regards  the
number of  fields.  The  signal  for a  new field  is  taken to  be  the
presence of 2 or more spaces between entries (3 spaces if the entry ends
with  a  sentence-terminating  punctuation  mark)  and  if  the  textual
material has already been justified and padded there may be cases  where
these conditions  are  met  in the  associated  textual  material.   The
program differentiates between these entirely on the basis of the number
of tabular entries that are expected and that have been found.

   CAUTION: It is unwise  to use ⊗XTJUST  on text that  one may want  to
re-⊗XTJUST or ⊗XTJFILL later, since any additional spaces at word breaks
which the first  ⊗XTJUST introduces  will be  taken as  a tabular  field
indicators during the execution of the subsequent commands.


⊗XTJGET

The command ⊗XTJGET determines the margin values of a designated portion
of text in a manner similar to that used by the ⊗XJGET command, except
that in addition to the crown, left, right and blanklines margins, the
positions and widths of tab fields are also set by ⊗XTJGET.

MARGIN CONTROL commands: ⊗XALIGN ⊗XINDENT ⊗→ ⊗← ⊗XCENTER
	(See p. 16 for basic justification information and other commands.)

   These  commands  preserve  the  identity  of  the  text  lines  while
preforming certain operations on their left margins.

   ⊗XALIGN moves all lines defined by the location of the arrow line and
a prefixed argument  (with 1  line or the  entire ATTACH  buffer as  the
default option) so that  all lines start with  a specified (or  default)
indentation.  The command uses initial TABs to the extent possible.  The
command can take a single suffixed decimal (sticky) argument to  specify
the desired indentation.  The initial default value is set at 0.

   The command ⊗XALIGN  may be set  to operate in  one of two  different
modes with  respect to  the  treatmant of  interior TABs.   The  initial
default mode is for all interior  TABs to be replaced by the  equivalent
number of spaces that they  produced before the alignment was  effected.
The other mode is entered by typing the letter T (for TAB) as a suffixed
letter (after the command name and separated from it by a space).   This
mode leaves all  interior TABs  untouched.  The  mode as  so changed  is
sticky and applies for  all subsequent ALIGN  and INDENT commands.   The
initial default  mode  may be  restored  by  typing the  letter  S  (for
spaces).

   INDENT simply moves the specified  number of lines (default value  of
1) except when in the ATTACH mode  when it is the entire ATTACH  BUFFER)
to the  right or  left  by the  specified  amount independent  of  their
original starting positions.  This  permits blocks of  code to be  moved
right or  left while  preserving their  original relative  indentations.
INDENT will takes one suffixed numerical argument specifying the desired
indentation, (a positive number if to the right or a negative number  if
to the left).  Motion to the left is limited by the edge of the page but
there is no practical limit to the motion to the right so take care when
changing the indent value.  The initial default indent value is 4.

   The command ⊗XINDENT may  be set to operate  in one of two  different
modes with  respect to  the  treatmant of  interior TABs.   The  initial
default mode is for all interior  TABs to be replaced by the  equivalent
number of spaces that they  produced before the alignment was  effected.
The other mode is entered by typing the letter T (for TAB) as a suffixed
letter (after the command name and separated from it by a space).   This
mode leaves all  interior TABs  untouched.  The  mode as  so changed  is
sticky and applies for  all subsequent ALIGN  and INDENT commands.   The
initial default  mode  may be  restored  by  typing the  letter  S  (for
spaces).

   The commands ⊗→ and  ⊗← are special cases  of INDENT.  They move  the
specified lines to the right or  left by the (absolute) amount that  had
been set  previously by  the ⊗XINDENT  command.  The  default number  of
lines is one if not  in ATTACH mode or it  is the entire ATTACH  buffer,
and the initial default indentation is 4.  Unlike ⊗XINDENT, these  arrow
commands do not require a ⊗X  or a carriage return.  Like ⊗XINDENT  they
limit the text motion to the left  edge of the page.  These commands  do
not take suffixed arguments.


Typical commands.

⊗XALIGN<cr>     ALIGN the  earrow  line (or  entire  ATTACH buffer  if  in
		ATTACH mode)  with  all  lines moved  to  start  with  the
		default ALIGN indentation (originally set to 0).

⊗4⊗XALIGN 5<cr>  ALIGN 4 lines starting with  the arrow line (or with  the
		start of the ATTACH buffer if in ATTACH mode) so that they
		are indented by 5.

⊗XINDENT<cr>    INDENT the arrow line (or  the entire ATTACH buffer if  in
		the  ATTACH  mode)  by  the   default  value  (set  to   4
		initially), but do not let any line move far enough to the
		left to lose any non-space characters.

⊗8⊗XINDENT 3<cr>  INDENT 8 lines starting with CURRENT by 3, that is, move
		the 8 lines  to the  right by  8 positions,  with the  new
		default value being set to 3.

⊗6⊗XIND T 3<cr>  INDENT 6 lines, starting with the arrow line, by 3  after
		changing the mode so that interior TABs are kept as TABs.

⊗6⊗XINDENT -3<cr>  INDENT 6 lines  starting with CURRENT  by -3, (that  is
		move them to the left by 3 positions).


⊗→              Move the CURRENT line or the ATTACH buffer contents to the
		right by the previously established amount.

⊗←              Move the CURRENT line or the ATTACH buffer contents to the
		left by the previously established amount.

⊗6⊗→            Move 6 lines starting  with the CURRENT  line or with  the
		start of the ATTACH buffer to the right by the  previously
		established amount.

   ⊗XCENTER centers all lines defined by the location of the arrow  line
and a prefixed argument (with 1 line or the entire ATTACH buffer as  the
default option) so that all lines are individually centered between  the
left and right margins as previously specified for the ⊗XJUST or ⊗XJFILL
commands, or desired values may be typed with the center command  itself
and these new values will then be the default values for the ⊗XJUST  and
⊗XJFILL commands.  See these other commands for full details.

   The command uses initial TABs to the extent possible.  Interior  TABs
are replaced by spaces before the centering is effected.
Other EXTENDED commands: ⊗X<cmd>

   Certain commands are potentially too dangerous to be safely evoked by
a single character.  There are also  more commands than can be  obtained
with single characters.  These contingencies  are handled by the  EXTEND
command specified as follows:

   ⊗X     Accept the string which follows as a command.  This
	  string may be abbreviated  as long as no ambiguity
	  results.  The string must be terminated by a space
	  if parameters are required,  or  by a <cr> or some
	  other delimiter.

Some EXTENDED commands (usually ended with carriage return):

   ⊗XALIAS <project>,<programmer>
		This command can be used to change your alias  PPN.
		It takes a following  text argument in exactly  the
		same form as the system  ALIAS command:  1) PRJ  to
		set project  to PRJ  and  programmer to  logged  in
		name, 2)  PRJ, to  set project  to PRJ  and  retain
		previous alias programmer name,  and 3) PRJ,PRG  to
		set both project  and programmer.   Note that  this
		command cannot  be abbreviated  beyond ALIA.   This
		command types  out  your  new  ALIAS  on  both  the
		current piece of paper  and PP 0  so that you  will
		see your changed alias when you exit.

   ⊗XAPPEND	Read in an additional page after the current one so
		that the two may be edited together.  The arrow may
		be moved up and down  on the combined pages  freely
		and the αP  command (with an  argument if  desired)
		may be used  to switch between  the in-core  pages,
		without affecting the APPEND status.  αβP  commands
		will, however,  release all  pages except  the  one
		specified.  The  ⊗XCANCEL command  (below)  cancels
		all corrections  on all  of the  in-core pages  and
		releases all pages except the first.

   ⊗XTHISPAGE	This command is useful for going from multipage
		mode (two or more pages in core, from having done
		an ⊗XAPPEND or a β<ff>) to single page mode (one
		page in core).  This command writes out the incore
		text and then reads in only the page where the
		arrow is.  The position of the arrow and (when
		possible) the window are preserved.  However, the
		line stack is currently cleared.

   ⊗XAUTOBURP	This command  can  be  used  to  set  or  read  the
		threshold  number   of   records   of   nulls   for
		autoburping.  If no  numeric arg is  given, E  will
		simply type out the current threshold.  A  positive
		arg to this command sets the threshold to that many
		records.   A   zero   or  negative   arg   disables
		autoburping entirely.  An arg of just "+" sets  the
		threshold to its default value, which is  currently
		19.  (A  page  to  be  written  out  that  has  the
		threshold number of records of nulls, or more, will
		be automatically burped  to delete  all records  of
		nulls from that page.)

   ⊗XBEEP       Beep me now.  This may be typed ahead whenever
		desired and you will be beeped when this
		command is reached.

   ⊗XBURP	Write out the current page and in the process reduce
		the disk space for that page to a minimum by deleting
		any all-null records from the current page.

   ⊗XCANCEL	Do not write out the current page but instead 
		reread it in from the disk.  See under ⊗XAPPEND
		above the treatment of appended pages.  See
		p. 8 for the effect ⊗XCANCEL has on line marks.

   ⊗XCHECK	Enable checking of free storage (currently the default);
		⊗-⊗XCHECK disables free storage checking;
		⊗0⊗XCHECK reports the current condition of free storage
		checking.  Macros which are to be executed many times
		(e.g., 100 or more) will often be executed significantly
		faster if free storage checking has been disabled.  It
		is recommended, however, that free storage checking
		normally be left enabled (except when you are repeatedly
		executing a macro) because internal E errors are
		detected much faster that way, with less chance for
		clobberage of your file.

   ⊗XCLOSE	Close the file.  This allows others to read it
		if you had modified it.

   ⊗XDDT	Branch to RAID if it is present.  αP returns.

   ⊗XDELETE	Delete the page mark between this page and the next.
		Note that using this command just after a ⊗XMARK
		command does not undo the newly inserted mark
		but it does delete the next mark.

   ⊗XDRAW	Redraw the complete screen.  Used when unwanted
		marks show on the screen from whatever cause.
		(This does the same thing as ⊗V).

   ⊗XFIND	See p. 13 for details on FIND, which does a search.

   ⊗XGORPG	Exit from E and repeat the last RPG command.

   ⊗#⊗XHEIGHT	Set the number of lines of display to be used to
		the decimal argument given (#).  There is a minimum of
		10 lines.  The maximum is terminal dependent.
		⊗XHEIGHT without an argument will reset the display
		size to the normal height.  (This command is
		especially useful on IIIs to reduce flicker.)

   ⊗XJUST	Justify the current page  (or the ATTACH buffer
		if in ATTACH mode) using the default values for
		the paragraph, left and right margins.  Margins
		are initially set to 1,1,69.  For elaborations on 
		this basic command, see p. 16.

   ⊗XLINCNT	Type out (1)  the number of  the current line,  (2)
		the number of  lines on the  current page, (3)  the
		number of  columns in  the  current line,  (4)  the
		number of characters on  the page, (5) the  current
		page number, and (6) the number of lines  attached,
		if any.

   ⊗XMAIL <destinations and switches>
     or
   ⊗XSEND <destinations and switches>
     or
   ⊗XREMIND <destinations and switches>
		Execute a system MAIL, SEND or REMIND command using
		text from the current page or attach buffer.  If  a
		numeric arg is  given with any  of these  commands,
		only that many  lines of text  are included in  the
		message.  If a zero arg is used, a one-line message
		can be sent entirely  from the ⊗X-command line  (no
		text  from  page  or  attach  buffer  sent).    For
		example, ⊗0⊗XSEND ME Hey, it really works!<cr> will
		send ME the  message "Hey, it  really works!"   You
		can also use the command line to include a  subject
		or an initial text line  ahead of the message  text
		being output  from  the page  (or  attach  buffer).
		That is,  ⊗!⊗XMAIL/SUBJECT  PRG Sending  mail  from
		E<cr> will mail the  current paragraph to PRG  with
		the subject "Sending mail from E".

		These commands are executed by starting up  another
		job  running  the  MAIL  program.   When  that  job
		finishes, it  will  type  out  a  message  on  your
		terminal reporting the  success or  failure of  the
		command.  Detailed  information on  failure is  not
		given.

		When there are  no job slots  for E to  start up  a
		MAIL job, mail sent from E is queued (by writing it
		into a  special  file  on RMD,SYS  which  will  get
		processed later automatically).  You are told  when
		this is  happening,  and  you  will  eventually  be
		notified of  the success  or  failure of  the  mail
		delivery.

		Also, whenever the MAIL program detects an error in
		mail coming from E, it will mail the whole  message
		and command back to the sender with an  appropriate
		message prefixed to it.

		See Appendix 4  in the Monitor  Command Manual  for
		full  details   on  the   form  of   switches   and
		destinations for these commands.


   ⊗XMARK	Insert a page mark between the CURRENT line and
		the line above it and display the new page.
		If there is an attachment when this command is 
		given, the attachment will be set down at the top
		of the newly created page.
		Note that this command name may be shortened to M
		but not to MA.

   ⊗XOPEN	Open the current file in Read-Alter (RA) mode (not
		legal in Readonly mode).  You should only use this
		command if you intend to make some change to the
		current file, since such opening of the file in RA
		mode will update the date/time written to the
		present.  THIS COMMAND IS NEVER NEEDED -- E will
		open the file in RA mode automatically when you
		first try to write out a page -- but ⊗XOPEN is
		useful if you intend to make some changes to a file
		and you want to make sure that when you actually do
		write out a page, no one reading the file will
		cause you to get the ENTER FAILED message that
		leaves you talking to the monitor with only two
		alternatives:  CONTINUE to try again and REENTER to
		write out the incore text in your E$SAVE.TXT file.
		Note, however, that the ⊗XOPEN command has no
		failure return -- if it can't open the file, this
		command itself generates the same ENTER FAILED
		message and the program stops and waits for you to
		type CONTINUE (or REENTER).

   ⊗XPROTECTION	Type out the protection key for the file
		being edited.

   ⊗XPROTECTION nnn	Change the protection of the file being
		edited to the octal value nnn.  Only 3 octal
		numbers may be given.  An attempt to change the
		protection of a file that is protection protected
		againt the user will not work.

   ⊗XREADONLY	Inhibit any further writing of the file.  You
		can leave  readonly mode  with the  ⊗XREADWRITE
		command (if the file is formatted).  If you try
		to write out  a changed page  while you are  in
		readonly mode  in  a  formatted  file,  E  will
		demand that you respecify the mode (readonly or
		readwrite)  that  you  want.   If  you   choose
		readwrite, the  changed  page will  be  written
		out.

   ⊗XREADWRITE	Enable writing  (modifying)  the  file.  The
		file must  be  formatted for  this  command  to
		work.  However, if you  are editing a  one-page
		unformatted file, this command will still  work
		by changing you to /N mode (no directory on the
		disk).

   ⊗XSPOOL	These  commands spool  on the line printer and XGP,
      and	respectively,  the  current  page,  or  the  ATTACH
   ⊗XXSPOOL	buffer if something is attached, without writing it
		out in the current disk file.  If a numeric arg  is
		given for either of these commands, only that  many
		lines of text  are spooled (they  are spooled  from
		the attach buffer if  anything is attached).   This
		allows you to spool a copy of changes that you have
		made whether or not you intend to incorporate  them
		into the  disk  copy  of the  file  that  is  being
		edited.  The spooled copy  carries the same  header
		information as it  would have carried  had it  been
		spooled in the usual way.  For spooling on the  XGP
		(⊗XXSPOOL  command),  the  default  font  and  page
		margins are used.

   ⊗XSIN(cr)    Put Spaces IN, in place of TABS, for example, so
		that the actual spacings will be preserved  when
		extra characters are added ahead of TABs.   This
		command may take a prefixed argument  specifying
		the number of lines to be operated on.   Without
		an argument it is applied to the entire page  or
		to the entire ATTACH buffer.

		This command will, of course, increase the space
		occupied  by the text  on the disk.  The inverse
		command, ⊗XTIN, should be used  to replace spaces
		by TABs, and then, this should be followed by an
		⊗XBURP before saving the page.

		SINning without TINning and BUrping is bad.

   ⊗XTIN	Put Tabs IN, in place of spaces, when this will
		result in a net saving in the space  occupied by
		the text on the disk.  Extra spaces  and/or TABs
		at the end of lines are also deleted.  No change
		is made in the way the text is displayed.   This
		command may take a prefixed argument, to specify
		the number of lines to be processed.  Without an
		argument it is applied to the entire page or the
		ATTACH buffer.  The inverse command is ⊗XSIN!

		While this command  reduces the number of spaces
		used in the text, it does not necessarily reduce
		the space that the text will occupy on the disk.
		The command ⊗XBURP should be used after  the ⊗XTIN
		command, for this purpose.

   ⊗XSAVE	Write out the current incore page(s) and any attach
		buffer in the  file E$SAVE.TXT on  your LOGIN  disk
     or		area.  This is  done automatically  for almost  all
		fatal errors detected  by E; when  it happens as  a
   monitor	result of such an error,  a message to that  effect
   command	is typed  out.  (The  file  E$SAVE.TXT may  NOT  be
   REENTER	written out successfully if  the error is  detected
		again while  writing  this file.)   Note  that  any
		previous E$SAVE.TXT file  is superseded  (replaced)
		by the new file.  Note also that this command  (and
		its automatic call upon  error detection) does  NOT
		touch the file you currently have open for editing.
		Whenever the E$SAVE.TXT file is written, E's TMPCOR
		file is also  written so that  the monitor  command
		ET<cr> will get you back to that point.

   ⊗XTELLME	Send a standard "error report" to ALS reporting the
		last few commands you have given and some interal E
		data.  This  command should  only  be used  if  you
		think you have just  seen a bug  occur in E.   This
		command provides valuable information for  tracking
		down possible bugs.  If  you use this command,  you
		should shortly  afterward  mail a  message  to  ALS
		explaining what sort of bug you think you just saw.

   ⊗XTMPCOR	Write out the TMPCOR file now to remember the
		current state of the edit stacks.  Also, this also
		causes the TMPCOR file to be written out whenever
		you subsequently leave a file, as if you had given
		as standard E monitor command originally.  This is
		sometimes useful to remember your place if you did
		something funny originally that normally inhibits
		use of the TMPCOR file (like, saying "R E;<file>"
		instead of "ETV file").  See the description of
		what goes in the TMPCOR file on p. 20.

   ⊗XWRITTEN	Type out  the date  and time  at which the  current
		file was previously written and the PPN and jobname
		of the  person who  did  it.  This  information  is
		saved even after you  have modified the file,  that
		is, even  after  the  system has  lost  this  data;
		however, once you switch away from a file this data
		is lost for that file.

   ⊗XVERBOSE	E can be in any one of three possible report states.
     and	The reporting state determines how much information
   ⊗XTERSE	E types out a various times.  The three states are:
		(1) the normal default  state, (2) a verbose  state
		achieved by the command  ⊗XVERBOSE and (3) a  terse
		state achieved by the command ⊗XTERSE.  The  normal
		state can be restored by giving either  ⊗-⊗XVERBOSE
		or ⊗-⊗XTERSE.  You can  find out the current  state
		by giving  either  ⊗0⊗XVERBOSE or  ⊗0⊗XTERSE.   The
		normal state now does somewhat less reporting (that
		is, less typeout) than formerly.  No error messages
		are ever suppressed by the terse state.

		The following remarks are currently suppressed only
		in the Terse state.

		    Only one MARK and you are there!
		    There are no marks!
		    Already marked!
		    Not marked!
		    All marks have been cleared.
		    Removing last MARK on this page.
		    MARKS on this page only have been cleared.
		    Page is empty.  (⊗XNDFAIL, ⊗XNDSAIL cmds)
		    Aborting macro ... (error occurred in macro)
		    Abort of # macros requested from ... (⊗#⊗XABORT cmd given)
		    No lines broken (⊗XBREAK command).

		The following remarks are typed out only in the
		Verbose state.

		    N characters added/removed (justify commands)
		    Line now has N chars. (join)
		    You have replaced XXX with YYY (substitute)
		    (detailed info of the parenthesis commands)
		    The new line of N chars lists M items (⊗XNDFAIL/SAIL commands)
		    Calling ... (calling a macro)
		    Ending ... (a macro has finished)


   ⊗XEMPTY	Move to the next empty or non-empty line.  A repeat
     and	argument will cause these commands to look for that
   ⊗XNONEMPTY	many empty or non-empty lines.  A negative arg will
		cause the search to  go backwards.  A positive  arg
		(or default of 1) will ignore the current line  and
		search from the  next line,  but will  not cross  a
		subsequent incore pagemark; hence the search is  of
		only one page.   These commands can  also be  used,
		both inside  and outside  macros,  to tell  if  the
		current line is empty--use  a zero arg:   ⊗0⊗XEMPTY
		is a no-op if the  current line is empty, but  will
		say something  and stop  any running  macro if  the
		current line is non-empty; ⊗0⊗XNONEMPTY is a  no-op
		if the  current line  is  non-empty, but  will  say
		something and stop any running macro if the current
		line is empty.


   ⊗XDPYALWAYS	Always re-display text after each command.

   ⊗XDPYSKIP	Don't re-display text if there are typed-ahead
		commands to be executed.  (normal mode)

   ⊗XINSERT	Same as β<form>; insert a page mark line.

   ⊗XPPSET	Reset screen position of page printer (the three
		lines at the bottom of the screen which echo commands).

   ⊗XQUIT	Exit WITHOUT writing out to the disk any text changes.
		All other commands that exit write out any changes first.
System commands and file SWITCHES.

(See also "Filenames, numeric extensions, and filehacks" on p. 29.)

   There are five main monitor commands available that run E in
various modes (for the first file edited).  These monitor commands
are: ETV, EREAD, CETV, READ and BOOK.  All of these commands restore
(upon startup) the list of the last few files you have edited along
with related information about each file.  When you exit from E, this
information is saved in a TMPCOR file (see details below) for later
restoration.  The meanings of these monitor commands are as follows.

ETV	Edit a file normally.

EREAD	Edit a file in readonly mode.  An E command is available to
	change from readonly mode to readwrite mode.  In readonly mode
	you cannot change the file.  See the /R switch later.

CETV	Create a new file with one empty text page and begin editing it.
	See also the /C switch.

READ	Read a documentation file.  This command will attempt to find
	the file on one of several system documentation disk areas and
	will then edit it in readonly mode.  See also the /D switch.

BOOK	Read a book file.  This command provides for keeping your place
	in the book over long periods of time (while you read it) but
	always edits the book in readonly mode without letting you
	change to readwrite mode.  See also the /B switch.

   Any of these monitor commands can be followed by zero, one, or
more filenames.  If no filename is given, then E edits the last file
previously edited.  If one filename is given, that file is edited.
Two filenames can be given to have E copy one file to another and
then edit either file; a left- or right-arrow is placed between the
filenames to indicate which file is to be copied, with the first file
listed always being the one edited.  Additional filenames can follow
the initial one (or two), preceded by commas -- such filenames
indicate files to be placed on E's file stack for editing later; this
mechanism is mainly used by E itself to remember the last few files
edited but is also available to the user for entering several
filenames.

   Any filename can be followed by switches that tell E the mode(s) in
which to edit the given file.  Also, if the first filename is omitted,
switches can still be inserted where that filename would be; such
switches apply to the last file previously edited (which will be edited
again).  The available switches are explained later.

   One more monitor command can be used to run E.  This one is different
from those listed above in that the use of it suppresses the normally
automatic remembering of the names of files edited.

R E;	Run E but don't restore information about previous files edited
	and don't remember information about current files edited.
	This command has little usefulness, especially since E normally
	remembers not just the last one, but the last three files you
	have edited.  Note that the filename(s) must be preceded by a
	semicolon.


	     THE TMPCOR FILE -- SAVING AND RESTORING YOUR
		 EDITING STACKS, LINE MARKS, AND MODES

   If you run E normally (by using any of the monitor commands listed
above except "R"), then when you exit, E saves information about the files
you have been editing.  (Actually, the information is saved each time you
leave a file, not just when you exit.)  When you return to E with one of
the same monitor commands, this information is restored.  The information
is remembered in a TMPCOR file (a temporary file in system core that goes
away when you log out).  When you leave a file, E remembers the names (and
stack positions) of the top three files in your file stack, and for each
file remembered, E also remembers the following: (1) the top part of the
page stack (including the final page, line and window position), (2) all
line marks, and (3) the current modes, including the settings of the /R,
/N and /F switches.

   When you return to E with one of the standard E monitor commands,
the TMPCOR file is read and the information there is stored by E
internally so that if you edit any of the same files again, the stacks,
line marks and modes for that file are restored to their previous
values.  For example, when you give the "ETV<cr>" monitor command with
no filename, E will edit the last file you were in and restore the
saved information for that file; in particular, E will start up editing
the file at the same page and line where you were when you left that
file.  Also, if you return to E with the monitor command "ETV
<filename><cr>", and if the file named was remembered in the TMPCOR
file, then the saved information for that file will be restored.  In
either of these example cases, other remembered files will have their
corresponding data saved, and the files will automatically be entered
in E's file stack; switching to such a file will cause the saved
information about that file to be restored.

  Whenever you edit a file by explicitly giving that file's name
(with or without an explicit filename extension), the state of the /R
flag is determined by the command you gave rather than by the previous
state of this flag.  If you edit a file without giving its name
explicitly, the /R flag is restored to its previous value unless the
command itself specifies a particular state for the /R flag (e.g.,
both the ⊗λ command and the EREAD monitor command specify /R).


SWITCHES

   A switch consists of an optional decimal number followed by a single
letter, all either preceded by a slash or enclosed in parentheses.  Any
number of switches may follow the filename that the switches are to
modify.  The infinity character "∞" may be used as the decimal number
for a switch, as in /∞F.  It represents a large positive value.

   For example, here are a couple of equivalent commands.

		ET E.ALS/R/7P/2L		ET E.ALS(R7P2L)

Switches are NOT ALLOWED in front of a filename.  "ET /R FOO" is illegal.

The available switches are listed below.  The inverse of any switch
can be specified by inserting a minus sign "-" between the slash
and the letter, as in /-R.  This is useful when you want to override
a positive switch default.

Note that if two switches specify conflicting conditions, the latter
switch overrides the switch occurring earlier.

	/C	Create a new file with the specified name.  This is of
                  most use when one wishes to create a new file with
                  the file switching command ⊗ε, perhaps to hold some
                  attached text from the current file.
	/R	Open the file in the read-only mode.  This is useful
 		  if one wants to examine a file without any danger
		  of inadvertently modifying it.  For example:
			ETV TEACH.TXT[UP,DOC]/R<cr>
                  You can leave read-only mode by using the ⊗XREADWRITE
                  command.  You enter read-only mode with ⊗XREADONLY.
	/B	Book mode.  Edit the file in book mode.  In this mode
                  you are never permitted to alter the file nor are you
                  permitted to leave this mode.  See the explanation of
                  book mode on p. 27.
	/N	No Directory.  Edit the file without writing a directory
                  on page one.  The directory must be generated from
                  scratch and the file reformatted each time you edit
                  the file.  The directory is kept in core by E but
                  never written in the file.
	/F	Repage and reformat the file with the maximum page size
                  limited to the default value of 33 (one screenful on
                  Data Disc terminals).  The F may be preceeded by a
                  decimal argument to use any desired number instead of
		  33.  Old page marks are retained, so it is not
		  possible to increase the page size by this switch and
		  some pages may be shorter than the specified length.
		  This switch is particularly useful for getting long
		  unformatted files into a shape where they can be
		  handled safely and easily.
	/F/R    (This is a combination of two switches.)  Repage and
		  reformat the core version only without changing the
		  disk copy.  The new directory will be on page 0 and
		  the old directory (if there is one) will be kept as a
		  part of the text starting on page 1.  Do not try to
		  use the old directory as it is invalid.  This switch
		  combination is particularly useful for examining
		  (without altering) unformatted files that have been
		  produced by programs other than E.
	/nP	Open the file at page n, where n is a decimal number.
        /mL     Open the file with the arrow at line m (m is decimal).
	/E	Open the file at the End of the last page.
	/nE	Open the file at the End of page n (decimal).
	/S      Open the file at the Same page and line the last file
		  was open at.
	/Q      Quietly assume a Yes answer to any questions E would
		  otherwise ask about formatting or replacing an
		  existing file or about discarding any invalid or
		  undesired directory.
	/x,yM	Place a line-mark on page x at line y.  Note that this
		  switch takes two decimal arguments separated by a
		  comma.  See the line marking commands on p. 8.  This
		  switch is a no-op when switching to the ? file or to a
		  file that you have already been in because previous
		  line marks in such a file are restored automatically.
	/x,yO	Push the position consisting of page x and line y on
		  the page stack for this file.  This switch also is a
		  no-op when switching to the ? file or to a file that
		  you have already been in because the previous page
		  stack in such a file is restored automatically.
	/D	Search the system documentation disk areas for the file
		  specified and then edit in Readonly mode whatever
		  file was found.  Thus you don't need to specify
		  either the extension or the PPN of documentation
		  files.  If no extension is given, then files with
		  extensions other than UPD will be found before UPD
		  files.  However, any explicit extension, project, or
		  PPN given will be observed.  If an extension is
		  given but no PPN, E will look for the particular
		  file on any of the documentation areas.  If a
		  project is given, say PRJ, then E will look for the
		  file on [PRJ,DOC].  If a programmer name is given,
		  then no searching of documentation areas will be
		  done and normal PPN scanning applies and the /D
		  will merely force the file to be edited in Readonly
		  mode.  The monitor command READ runs E and implies /D.

Here are some examples of the monitor command READ and the /D switch.

  READ UUO        Edits the UUO Manual file in readonly mode.
  READ UUO.UPD    Edits the update file for the UUO Manual in readonly mode.
  ⊗εMONCOM/D      Switches to the Monitor Command Manual in readonly mode.
  READ NOTICE/E   Edits the NEWS program's text file of notices in readonly
		  mode, starting at the End.


NEED TO REFORMAT FILE, or WOULD YOU SETTLE FOR /R MODE, or FOR /N MODE?

   If you try to edit, in readwrite mode, a file that does not have a
valid E directory, E will tell you that the file needs to be reformatted
and will ask if that is ok.  If you say Yes (just Y), then E will format
the file and add a directory page at the beginning of the file.  If you
say No (just N), E will give you some alternatives.  These include
editing the file in readonly mode (/R) (for which E does not need a
formatted file) and editing the file in no-directory mode (/N) (for
which E will have to format the file so that each page begins on a
record boundary, but no directory page will be written at the beginning
of the file).  If you say No to each of the alternatives, E will ask for
a new filename.  If you type <altmode> in place of Y or N for any
alternative, E will forego the remaining alternatives and immediately
let you give a new filename.

   To any of the Yes or No questions about formatting, you can respond
/R to tell E to edit the file in Readonly mode, or you can respond /N to
tell E to edit the file in No-directory mode.  Like the normal responses
(Y or N), the special responses /R and /N do NOT take a carriage return.
Using E from a non-display (TTY).

It is possible to use E from a non-display terminal.  Of course, some of
the advantages of E over, say, SOS are lost but one may not want to go
to the trouble of having to switch editors in mid-stream.  As partial
compensation for the lack of display features, E provides the
non-display user with optional line numbers.  See the MONITOR COMMAND
MANUAL sections 3 and 4.7 for other information of interest to
non-display users.

No special action is required of the non-display user to tell E that
a non-display is being used.  E figures that out automatically.

An important and useful command on non-displays is ⊗XTYPE, which
types out a number of lines.

  ⊗#⊗XTYPE<cr>	Types # lines starting at CURRENT and moves CURRENT
		past those lines.  If # is omitted, 10 lines are
		typed if on a non-display terminal, but only 1 line
		is typed if on a display terminal (useful for seeing
		long lines that go beyond right edge of display).

The following command can be used to enable or disable the typing
of line numbers that E normally does when typing out the text of
lines.

  ⊗XNUMBERS<cr> E lets you select whether or not you want line numbers
		typed out.  The command ⊗XNUMBERS enables typing out
		line numbers and the command ⊗-⊗XNUMBERS disables
		typing line numbers.  In ⊗-⊗XNUMBERS mode on a
		non-display, when you go into line insert mode, E types
		out a once-only prompt and tells you the line number of
		the first line you are about to insert.  The current
		initial default is ⊗-⊗XNUMBERS (no line numbers).  The
		command ⊗0⊗XNUMBERS restores the line numbers mode to
		its initial default (currently ⊗-⊗XNUMBERS).

Here are some arguments for using each mode:

XNUMBERS:  In this mode you always know where you are on a page; and
	   when you are in line insert mode, you get a prompt (of the
	   line number) to remind you that you are inserting text.
	   Blank lines are obvious because of the leading line number,
	   unlike in -XNUMBERS mode where a blank line of text typed out
	   may go unnoticed.

-XNUMBERS: In this mode, typeout of lines is a little faster, since the
	   leading line number and tab are omitted.  Also, the resultant
	   typeout of each line is 8 spaces shorter, thus making fewer
	   long lines wraparound on each given-width terminal.
	   Furthermore, in line insert mode, a one-time prompt tells you
	   at what line number on the page you begin inserting text, and
	   the text that you insert is flush with the left margin.  Thus
	   a ↑U (clear input line) command to the monitor (which puts
	   you back at the left margin on the next line) leaves you
	   still properly lined up with text from previous lines.


TYPING COMMANDS FROM NON-DISPLAYS:

Initially, each character typed to E from a non-display is assumed
to be a command; that is, the character is read by E as if it had
been typed with the CONTROL key depressed.  One can, however, enter
LINE-INSERT mode by typing the character I and then everything
thereafter is accepted as text to be inserted until ALTMODE (ESC on
some terminals) is typed.  Of course, when the non-display user
types the command character X, E waits for an extended command
name to be typed followed by a carriage return.

The LINE EDITOR is not available on non-displays, so it is not
possible to arbitrarily edit an existing line on a non-display.
However, it is possible to use the substitution commands (using the
linefeed delimiter at the end of the search string) to change part
of one or more lines.  Also, the ⊗XBREAK and ⊗XJOIN commands can be
used to separate out part of a line that you want to change.

The following two extended commands allow the user on a non-display
to execute commands that require precisely just the CONTROL bit or
precisely both the CONTROL and META bits.  These are prefix commands
which affect the following command.

 ⊗XMETACONTROL  This causes the next character to be interpreted
		as if it had both the META and CONTROL bits.
		This is useful on a non-display when you want to
		use a command that requires both META and CONTROL.

 ⊗XCONTROL      This causes the next character to be interpreted
		as if it had the CONTROL bit but NOT the META bit.

If neither of the above two commands is used on a non-display, a
command that makes a distinction between CONTROL and META-CONTROL
will execute the CONTROL version; and a command that distinguishes
between any bits and none at all will execute the no-bit version.

The control key on a non-display is not at all the same as the
Stanford-keyboard CONTROL key referenced in most of this manual.

Some characters cannot be typed from a non-display to a user program
(like E) because their use has been preempted by the system.  Thus
it is impossible to input those characters as text in E.  However,
where such characters are used as commands by E, there is an
alternative extended command that does exactly the same thing as the
single-character command which the system intercepts.  The table
below lists these extended commands and the single-character
commands they represent.  For details on what these extended
commands do, see the writeups in this manual for the corresponding
single-character commands.

Extended	Equivalent Single-Character Command
Command

⊗XEXIST		⊗∃ (there-exists sign, octal 025, ↑U (intercepted by system))
		   Types out file-switch list.
⊗XPARTIAL	⊗∂ (partial-sign, octal 017, ↑O (intercepted by system))
		   Carries out next command on current message.
⊗XMSG		⊗∂ (partial-sign, octal 017, ↑O (intercepted by system))
		   Carries out next command on current message.
⊗XLAMBDA	⊗λ (lambda, octal 010, ↑H) Switches files.
⊗XLOOKUP	⊗λ (lambda, octal 010, ↑H) Switches files.
⊗XEPSILON	⊗ε (epsilon, octal 006, ↑F) Switches files.
⊗XENTER		⊗ε (epsilon, octal 006, ↑F) Switches files.

Stanford characters that cannot be sent as text or as E control
characters are:

Octal	Usual		Prints	Typed	Preempted as a system
	name		out as	in as	  command used for

002	alpha		α	<ctr>B	type-out pause (toggles)
003	beta		β	<ctr>C	monitor call
017	delta		∂	<ctr>O	flush type-out (toggles)
025	there exists	∃	<ctr>U  clear input line
032	tilde		~	<ctr>Z  end of file
033	not equal	≠	<ctr>[  altmode


Character equivalences, Stanford AI Lab character set:

Code	Name		Prints	Typed	Preempted
octal			out as	in as	for

000	null
001	down arrow	↓	<ctr>A
002	alpha		α	<ctr>B	type-out pause (toggles)
003	beta		β	<ctr>C	monitor call
004	logical and	∧	<ctr>D
005	logical not	¬	<ctr>E
006	epsilon		ε	<ctr>F
007	pi		π	<ctr>G

010	lambda		λ	<ctr>H
011	TAB
012	LF
013	VT
014	FF
015	CR
016	infinity	∞	<ctr>N
017	delta		∂	<ctr>O	flush type-out (toggles)

020	containment	⊂	<ctr>P
021	implication	⊃	<ctr>Q
022	intersection	∩	<ctr>R
023	union		∪	<ctr>S
024	for all		∀	<ctr>T
025	there exists	∃	<ctr>U  clear input line
026	circle times	⊗	<ctr>V
027	double-arrow	↔	<ctr>W

030	underbar	_	<ctr>X
031	right-arrow	→	<ctr>Y
032	tilde		~	<ctr>Z  end of file
033	not equal	≠	<ctr>[  altmode
034	less or equal	≤	<ctr>\
035	greater or eq	≥	<ctr>]
036	equivalence	≡	<ctr>↑
037	logical or	∨	<ctr>←

040	SP
041	exclamation	!	!
042	double quote	"	"
043	number sign	#	#
044	dollar sign	$	$
045	percent		%	%
046	ampersand	&	&
047	close s. quote	'	'

050	left paren	(	(
051	right paren	)	)
052	asterisk	*	*
053	plus		+	+
054	comma		,	,
055	minus		-	-
056	point		.	.
057	slash		/	/

060	digits		0	0
...
071			9	9
072	colon		:	:
073	semicolon	;	;
074	left broket	<	<
075	equal		=	=
076	right broket	>	>
077	question mark	?	?

100	at sign		@	@
101	upper-case	A	A
...
132			Z	Z
133	left bracket	[	[
134	back slash	\	\
135	right bracket	]	]
136	up¬arrow	↑	↑
137	left-arrow	←	←

140	open s. quote	`	`
141	lower case 	a	a
...
172			z	z
173	left brace	{	{
174	vertical bar	|	|
175	ALT			ALT or ESC
176	right brace	}	}
177	BS or DEL		BS or DEL
PARENTHESIS finding/matching commands: ⊗( ⊗) ⊗XLPAREN ⊗XRPAREN ⊗↔ ⊗XPAREN ⊗XPINFO

   This set of commands  allows one to check  nested sets of  bracketing
symbols for matching pairs and  for related properties.  The search  may
be restricted to the current page by using  the ( and ) forms or it  may
be extended over the rest of the file by the extended commands  ⊗XLPAREN
and ⊗XRPAREN.  It always starts from  the location of the cursor at  the
time the command is  given and proceeds in  the forward direction.   The
nesting level  is  re-assigned  the  value 0  at  the  cursor's  current
position for each new command (see special conventions below).

   The default symbols are  the normal parentheses (  and ).  An  EXTEND
command ⊗XPAREN  allows one  to  define any  desired set.   The  command
itself must be  delimited by  a space and  followed by  the desired  two
characters and a carriage return.  If  the desired pair is from the  set
→←, ⊂⊃,  `', ≤≥,  {}, <>,  [], then  only the  first of  the set  and  a
carriage return should  be typed.  If  another set had  been chosen  the
default set may be reset by  typing the setting command with a  carriage
return only.

   Note, that a space is an acceptable symbol and for this reason  extra
spaces are not permitted in the  command string.  A distinction is  also
made between upper and lower case  characters so that both may be  used.
In the special case when the same character is assigned to both symbols,
the concept of nesting has no  meaning and the commands are  interpreted
differently, as noted in the special section below.

   In what follows, the two symbols  of the chosen set will be  referred
to as the left-symbol and the right-symbol respectively.

   The normal commands are then  ⊗( and ⊗).  Each  of these may take  an
argument which specifies  the sought-for  nesting level  for the  region
defined by the bracketing  symbol.  The default argument  is 1 for  both
commands.  The corresponding extend commands are ⊗XLPAREN and  ⊗XRPAREN.
These commands may be given both when not in the line editor and when in
the line editor.  If given when in the line editor the line will not  be
written out should the  search be unsuccessful or  should the search  be
successful with the found symbol in the same line.  A successful  search
that results in leaving the line editor to go to another line will cause
the original line-editor contents to be written.

   There is one additional command ⊗↔ which, in effect, un-does the last
⊗(, ⊗), ⊗XLPAREN, ⊗XRPAREN or ⊗↔  command and returns the cursor to  its
former position.

   Note that the most frequent use of these command will be in LISP
   where one wants  to find matching parentheses, and hence the use
   of ( and ) for the commands and for the default symbols.

   SAIL users may find it useful to  define an otherwise unused set
   of symbols to  mean BEGIN and END (some people already use ⊂ and
   ⊃ for this purpose), and to use these symbols in their stead, at
   least while debugging.

Special conventions

A special convention has been adopted to avoid ambiguity for those cases
in which these  commands are given while the line-editor cursor is under
one of the searched-for bracketing  symbols.  This convention is that  a
cursor under a left-symbol is presumed  to be actually to its left, that
is,  outside  of  the  symbol  (as it  appears)  and  a  cursor  under a
right-symbol is presumed to be  actually to its right, again  outside of
the symbol (and again as it appears).

   Arguments, when used with these commands refer to the desired nesting
level within the region defined by the nesting pairs.  If no argument is
given, the default value is 1,  in accordance with the usual  convention
for most  E commands.   As  a mnemonic  aid,  the sought-for  symbol  is
reported  with  the  argument   shown  after  left-symbols  and   before
right-eymbols although  the argument  must always  be typed  before  the
command (to permit  the command  character, itself,  to be  used as  the
activator).

   By convention the starting  level is always re-assigned the  value 0.
Left-symbols increase  the nesting level and right-symbols decrease the
level.

Typical commands

⊗4⊗(	Move  the  cursor  to that  left-symbol which  would  cause  the
nesting to reach a  level of 4, considering the  present cursor position
to be at level 0.  Do not move the cursor if this level is not found and
report the deficiency.  This request  is reported as (4 for the  reasons
noted above.

⊗(	With no argument, this command finds the very first left-symbol.
If the cursor is already at a left-symbol this command is a NO-OP.  This
is  in consequence of the  convention that a cursor  under a left-symbol
actually refers to the situation just ahead of the symbol.

⊗XLPAREN   This is the same as ⊗( except that the search is permitted to
continue past the end of the current incore page(s).

⊗)	If the  cursor is  already positioned  under a left-symbol, move
the cursor to  the matching right-symbol.  If the cursor is not  under a
left-symbol, then search  for that right-symbol that returns returns the
nesting level to its initial value of  0.  Should the cursor be under  a
right-symbol, the initial level is taken to  be that at its right.  Note
that  this command is a NO-OP only for  the case where the desired level
cannot be found.  This request is reported as 1).

   If the end of the text is reached before a transition from level 1 to
level 0  is found, the cursor  is left in its  original position and the
deficiency is reported along with the other data.  Deficiencies, in this
case can be of two sorts, either a level of 1 is never reached or having
been  reached  and possibly  exceeded  as  a result  of  left-symbols, a
right-symbol is  never encountered while  at this  level.  In  the first
case, the deficiency figure  is reported following a down arrow (meaning
always below).

⊗XRPAREN   This is the same as ⊗) except that the search is permitted to
continue past the end of the current incore page(s).

⊗3⊗)	Search through the text as just described but stop at  the first
right-symbol that reduces the nesting-level from the specified level, in
this case 3.  This request is reported as 3).

Interpretation when the same character is used for both symbols:

   Both the ( and the ) command, in this case, ignore the symbol that is
above the cursor at the time the command is given and search for the Nth
next example of the  specified symbol, where N  is the argument that  is
used with  the command.  The ( command  is not a  NO-OP in  this special
case.

INFORMATION ABOUT PARENTHESIS SEARCHES

In the Terse or normal reporting states, E does not type out all the
possible information when a parenthesis search is done.  To find out
all this information, use the following command, or be in Verbose
mode when the search is done.

   ⊗XPINFO	Type out information about the last parenthesis
		search done.

Swapping To and From E via RPG startups: ⊗XRSYS ⊗XRUN ⊗XGORPG ⊗XDRD ⊗XTV

A user program can start up E and have it automatically edit a
particular file at a specific place, with the capability of returning to
the original program or to any other particular program.  Furthermore, E
has commands that cause it to swap to certain system programs or to any
named system or user program.

In each of these cases, whether coming from E or going to E, the new
program is started up at the so-called "RPG startup address", namely, at
1 beyond the normal starting address.  This is usually done with the
SWAP UUO by specifying a starting-address increment of 1.

The commands to start up another program from E are listed below.
Each of these first puts down any attach buffer and writes out to the
disk any changes on the page before swapping to another program.

    ⊗XRSYS <program>   This runs the given system program (device SYS:)
		       with an RPG startup.  See also next paragraph.

    ⊗XRUN <program>    This runs the given user program (device DSK:)
		       with an RPG startup.  See also next paragraph.

    ⊗XGORPG            This runs the system program SNAIL (formerly RPG)
		       with an RPG startup.

    ⊗XDRD              Either of these runs the system program DIRED
      or	       with an RPG startup.
    ⊗XDIRED

    ⊗XTV	       Runs the system program TV with an RPG startup
		       to edit the current file with TV (ugh!).

If the <program> is omitted from the ⊗XRSYS or ⊗XRUN command, and if E was
originally run with an RPG startup, then the program run by the command
will be the program whose name was in ACs 0-3 when E was started up (see
below for the AC contents expected by E on an RPG startup).  Thus a
program that wishes to swap to E and to have E swap back to it can set up
the ACs as described below and swap to E using the RPG startup (starting
address plus 1).


When E is run via an RPG startup, it expects certain data to be in the ACs
(placed there before the SWAP was done).  When E starts up another program
via the ⊗XRSYS or ⊗XRUN command, it leaves this same data in the ACs.
This data is listed in the table below.  (RH means "right half" of the
AC, and LH means "left half".)

  AC	Data in AC upon RPG startup (starting address + 1)

   0	Name of program file
   1 LH	Extension of program file
   2	
   3	PPN of program file
   4	
   5	
   6	Device of program file
   7	
  10	
  11	PPN of edit file
  12	Device of edit file or zero for DSK:
  13 LH	Extension of edit file
     RH Mode bits (see below)
  14	Name of edit file
  15 LH	Attached-line count+400000, or column position within line, or zero
     RH	Line number in edit file
  16	Page number in edit file
  17

Coming from E (⊗XRSYS or ⊗XRUN), ACs 0-6 will contain the name of the
program that E is swapping to, and ACs 11-16 will contain the name of the
edit file that was being edited by E.

In swapping to E, ACs 0-6 contain the name of the program that E should
swap back to upon an ⊗XRSYS or ⊗XRUN command given without a program name,
and ACs 11-16 contain the name of the file E should edit.  If AC 14 (name
of edit file) contains zero, E will read the name and starting page and
line of the edit file from the normal editor TMPCOR file (ED), and the
TMPCOR file will be updated upon exit.  Otherwise, the TMPCOR file is
neither read nor written for an RPG startup.

The mode bits in the right half of AC 13 are:

  Bit	Octal	Meaning

  18	400000	Create this file.
  19	200000	Edit in readonly mode (/R).
  20	100000	Edit in no-directory mode (/N).


Message and paragraph handling commands: ⊗∂<cmd> ⊗0⊗∂ ⊗!<cmd> ⊗0⊗!

MESSAGE HANDLING COMMAND: ⊗∂

The new  partial-sign (∂) command  is designed  for easy handling  of
messages in mail files,  but it can be used on any file regardless of
whether the  file contains mail-like  messages.   For instance,  this
command is capable of attaching (or deleting) a whole page of text at
once and simultaneously deleting the pagemark for that page.

The  ⊗∂ command is  a search command  used to find  the beginnings of
"messages."  A message is defined  as the  largest contiguous set  of
lines of which only the  first starts with a partial-sign (∂) and the
last of  which  is followed  either  by another  line  starting  with
partial-sign or  by the  end of  the page.   The  current message  is
defined as the  message containing the current line (the arrow line).
If the arrow is on the row  of stars that marks the end of the  page,
then the current message is the  one that contains the last real line
of the page.

Messages are never considered  to extend across page boundaries.   If
neither the  current line nor  any of the  lines preceding it  on the
current page starts with a  partial-sign, then the current  "message"
starts with the first line of the current page.  If none of the lines
(on  the  current   page)  below  the  current  line  starts  with  a
partial-sign, then the last line of the current "message" is the last
line on the  page.  Thus, if  there are no lines on  the current page
that start with ∂, then the current "message" is the whole page.

Like the  ⊗F command,  the ⊗∂  command requires  a following  command
before any  action  is taken  (with  one exception,  which  is  noted
below).  However,  the ⊗∂  command does  not accept  a search  string
before the second  command; ⊗∂  always searches  for lines  beginning
with a partial-sign.  If the command following is one of the  special
commands that use the number of lines searched (for instance, by  the
⊗F command) as the argument to the command, then that command will be
carried out for the  entire current message.  If  the command is  not
one of these special ones, then it will be executed at the  beginning
of the next message.

Currently the special commands that use the number  of lines searched
as the  command argument are:  αβD (delete), ⊗A  (attach), ⊗C (copy),
⊗←, ⊗→, ⊗XALIGN, ⊗XCENTER, ⊗XINDENT, ⊗XJFILL, ⊗XJOIN, ⊗XJUST.

The ⊗∂ command may be preceded by a numeric argument which  specifies
the number  of messages  (starting with  the current  one) which  the
command is to  affect.  If that number is negative, then the messages
just before the current one are the ones effected, with  the absolute
value of the argument specifying how many messages.


N.B.: A zero argument to the  ⊗∂ commands means move to the beginning
of the current message WITHOUT WAITING FOR A SECOND COMMAND.  This is
the only case where a second command is not used by the ∂⊗ command.


!!!!! SPECIAL FEATURE OF THE PARTIAL-SIGN COMMAND !!!!!  N.B.: If the
partial-sign command  is used  with ⊗A  (attach) or  αβD (delete)  to
attach or delete  every line on  the current page,  then the  current
page  itself,  i.e.,  its  pagemark,   will  also  be  deleted.    In
particular, if the  current page is  not the last  page in the  file,
then the following pagemark will be  deleted, leaving you at the  top
of that page; if the current page is the last page in the file,  then
the preceding pagemark will  be deleted and you  will be left at  the
bottom of the previous  page.  No pagemark deleting  will be done  if
the file has only one page  besides the directory, but in this  case,
if the file is a message file (extension .MSG) on [2,2], then a  flag
is set which will  cause the file  to be deleted  (since there is  no
text in it) when you leave it  unless you do something to change  the
file (add  text  or pages)  before  then.   And note  that  the  page
deleting only happens when the  entire page's text is either  deleted
or attached using the partial-sign command!


If there are already some lines in the attach  buffer at the time you
give  an ⊗∂⊗A command, the  new messages being attached  are added at
the end of  the attach  buffer.  If  you give a  ⊗-⊗∂⊗A command  when
there are already lines in the  attach buffer, the new messages being
attached are inserted at the beginning of the attach buffer, ahead of
the text already there.


Here are some  example uses  of the partial-sign  command.  The  ones
marked with  an asterisk (*)  all involve either  αβD or ⊗A  and will
delete a  pagemark in  addition to  the action  noted if  the  action
results in  an empty  page which is  not the  only page (besides  any
directory) in the file.


	⊗∂αβD	  ;* Deletes the current message.
	⊗∂⊗A	  ;* Attaches the current message.
	⊗∂⊗C	  ;Copies the current message into the attach buffer.

	⊗-⊗∂<cr>  ;Moves to beginning of previous message.
	⊗0⊗∂	  ;Moves to beginning of current message.
	⊗∂<cr>	  ;Moves to beginning of next message.

	⊗∂<bs>	  ;Moves to end of current message.
	⊗∂⊗J	  ;Moves to beginning of next message and jumps screen up.
	⊗∂αβ<cr>  ;Enters line-insert mode between the end of the
		  ;current message and the beginning of the next one.

	⊗3⊗∂αβD	  ;* Deletes three messages starting with the current one.
	⊗3⊗∂⊗A	  ;* Attaches three messages starting with the current one.
	⊗3⊗∂⊗C	  ;Copies three messages starting with the current one.

	⊗-⊗2⊗∂αβD ;Deletes the two messages preceding the current one.
	⊗-⊗2⊗∂⊗A  ;Attaches the two messages preceding the current one.
	⊗-⊗2⊗∂⊗C  ;Copies the two messages preceding the current one.


PARAGRAPH HANDLING COMMAND: ⊗!

The  exclamation-point  (!)  command  has  been  added  to  operate   on
PARAGRAPHS in the same way that the partial-sign (∂) command operates on
messages.

However, UNLIKE the ⊗∂ command, the ⊗! command never deletes a pagemark.

    NOTE: "PARAGRAPH" here means a contiguous group of non-empty lines
    plus certain surrounding empty lines (if any).  Included in the
    paragraph of the ! command are: one empty line (if any) at the
    beginning of the paragraph and all but one of any empty lines at the
    end of the paragraph.  However, if the last line of a page is blank,
    it is considered part of the paragraph containing the previous line.

The two  commands !  and ∂  don't actually  do anything  until you  type
another command.  If  that following command  accepts a search  distance
argument, then the effective argument will be the number of lines in the
current paragraph  (!  command) or  message  (∂ command);  for  example,
⊗!⊗XJUST<cr> will justify the current "paragraph".  If the command  that
follows ⊗! or ⊗∂ does NOT  accept a search distance argument, then  that
command is  carried  out after  moving  to  the beginning  of  the  next
paragraph (!)  or message  (∂).   The one  case in  which  the !  and  ∂
commands don't  take  a  following  command is  when  a  preceding  zero
argument has been supplied  (that is, ⊗0⊗! or  ⊗0⊗∂), in which case  the
command immediately moves to the beginning of the current paragraph  (!)
or message (∂).
MACROS: ⊗XDEFINE ⊗Z ⊗Y ⊗XRESUME ⊗XABORT ⊗# ⊗XSTOPALL ⊗XSTOPONE ⊗XSTOPZERO ⊗XSTOPHOW
	(Additional commands relevant to macros are explained on p. 26.)


DEFINING AND CALLING MACROS--MACRO NAMES

Macros are provided in E to save the user the effort of typing the same
things over and over again.  A macro represents any number of characters
that should be "typed" to E as commands and text whenever that macro is
called.  A macro is defined with the command

	⊗XDEFINE <macro name><cr>

where <macro name> can contain letters and digits (it can even start with
a digit or contain only digits) or it can be entirely blank.  Only the
first six characters of a <macro name> are significant, but beyond that a
<macro name> can NEVER be abbreviated.  After giving the ⊗XDEFINE command,
the user types the characters (commands and/or text) which the macro is to
represent.  The definition is ended by typing αβ<lf> on displays or ↑Z on
non-displays.  When you end the definition, the macro's name and
definition will be typed out unless the definition was made during macro
expansion (i.e., by another macro).

A macro can be called by either

	⊗Z<macro name><cr>
or
	⊗Y

where the latter calls the last macro either defined or called.

Each of these macro-calling commands causes the macro definition to be
expanded by treating the commands and text of the definition as if they
were being typed in by the user.  The ⊗Y command allows the user to
repeatedly call the same macro with a single keystroke each time, but
only until the user either calls (with ⊗Z) or defines another macro.
Named macros and the ⊗Z command allow the user to define and use as many
macros as he wants.

When all macro expansion is terminated for any reason, an ALTMODE
character is used as the next input character to force completion of any
partially-typed command.  However, there is one major exception to this
rule.

    If the macro expansion runs to completion and the effect of the last
    characters in the macro is to leave a line of text (from the file) in
    the line editor, then the normally-inserted ALTMODE is omitted and the
    text is left in the line editor.

While macro expansion is in progress, there are no prompts given (like
"COMMAND?"), "OK" is never typed out, and the display is never updated.
However, the ⊗V command always redraws the screen immediatetly, even
when encountered during macro expansion.  Thus you can put ⊗V commands
into your macro definition to let you watch the progress of the macro.
Note that αβV erases the screen and then redisplays, whereas αV just
redisplays the screen (this is true outside of macro expansion as well
as inside).


ITERATIVE AND RECURSIVE MACRO EXPANSION

Iteration:  A positive repeat argument on a macro call will cause the
macro to be expanded a number of times.  For example,

	⊗3⊗Z<macro name><cr>
or
	⊗3⊗Y

will cause the macro to be expanded three times.  Negative arguments to
macro calls are reserved for future use, although they currently result
in making a macro call a no-op.  A zero argument will cause the macro
name and definition to be typed out, as explained below.

Recursion:  A macro can call other macros or even itself.  When a called
macro finishes, control returns to the calling macro, which then
continues its own expansion.  A pushdown stack is used to keep track of
the macro calls (expansions) currently in progress.  This macro stack
currently has a length of about 24, thus allowing nested macro calls up
to that depth.


FINDING OUT MACRO NAMES AND DEFINITIONS--STANDARD REPRESENTATION OF DEFINITIONS

Arguments of zero are used to have macros and their definitions typed
out.  The command

	⊗0⊗XDEFINE<cr>

will type out the names of all defined macros.  A zero argument to a
macro call will simply cause the macro's name and definition to be typed
out; that is, use

	⊗0⊗Z<macro name><cr>
or
	⊗0⊗Y

with the second form also being useful for finding out which macro the
next ⊗Y command would call.

Macro definitions are always typed out using a text representation which
allows for the CONTROL and META bits and non-printing characters (such
as formfeed).  This same representation is used when reading or writing
macro definitions from or to the incore page and command files--see p. 26
for those commands.

Actually, there are two representations available, the standard
representation and the alternate representation.  The standard version
is always used for typing out definitions, but either or both can be
used when reading definitions from the incore page or from a command
file.  These representations involve three special escape characters and
several ignored characters.  The characters ignored are

	TAB,ALT,CR,LF,BS,VT, and FF.

The three escape characters are

	"⊗", "α" and "β".

To represent any of the seven ignored characters or any of the three
escape characters, two characters are used, namely, the character "⊗"
(circle-x) followed by a character specifying which special character
you want.  These representations are listed in the table below.

The character alpha (α) causes the next command to have the CONTROL bit
added.  The character beta (β) causes the next command to have the META
bit added.  Thus "αβV" represents CONTROL-META-V.

     Representations	  Corresponding commands to E
   Standard  Alternate
      ⊗⊗	⊗⊗	  ⊗	circle-x
      ⊗=	⊗T	  TAB	horizontal tab
      ⊗≠	⊗A	  ALT	altmode
      ⊗↔	⊗C	  CR	carriage return
      ⊗↓	⊗L	  LF	linefeed
      ⊗↑	⊗B	  BS	backspace
      ⊗←	⊗V	  VT	vertical tab
      ⊗→	⊗F	  FF	formfeed
      ⊗α	⊗X	  α	alpha
      ⊗β	⊗Y	  β	beta
      α		⊗1	  Add CONTROL bit to next command
      β		⊗2	  Add META bit to next command

For example, CONTROL-META-LINEFEED is represented by "αβ⊗↓" or "αβ⊗L" or
"αβ⊗l".  The case of a letter following "⊗" is irrelevant, but
otherwise, if a "⊗" is followed by a character other than those listed
above, an error will result and the command will not be completed.

Note:  These representations are NOT usable in the ⊗XDEFINE command when
defining a macro from the terminal.  Definitions typed in from the
terminal are entered verbatim--no character conversion.


UNDEFINING MACROS

A macro can be undefined by giving the ⊗XDEFINE command with a negative
argument.  Thus the command

	⊗-⊗XDEFINE <macro name><cr>

makes E completely forget about the named macro.


ERRORS DURING MACRO EXPANSION

The user can select the action to be taken when an error ("SORRY --
...")  occurs inside a macro.  The default action is to stop all macro
expansion, but the user can give any of three extended commands to
select the current error action from three possibilities.

    ⊗XSTOPALL	On error, stop all macro expansion.  This is the default.

    ⊗XSTOPONE	On error, stop the current macro and return control to any
		higher level calling macro as if the current macro had
		finished.

    ⊗XSTOPZERO	On error, ignore the error and let macro expansion continue.

There is one additional extended command to find out what the currently
selected error action is.

    ⊗XSTOPHOW	Report which of the above three actions is currently selected.

Also, any argument given with any of the three previous commands will
suppress selecting an action, but will report the current error action.

When E needs an answer to a Yes or No question while processing some
command, it will get the answer FROM THE USER'S TERMINAL, NEVER FROM A
MACRO DEFINITION.  Unless the answer is Yes, macro expansion is treated
as if a command error had occurred, and the current error action is
taken.

Macro expansion is stopped unconditionally if a macro tries to stuff
more text into the line editor than E has room for in its buffer.  Note
that E's buffer is considerably bigger than the line editor's, so it is
still possible to lose some text (without stopping any macro) if a
macro's line editor text is slightly too long for the line editor.


ABORTING AND RESUMING MACRO EXPANSION

Four ESCAPE commands are available for interrupting macro expansion.
These are ESC I, ESC 1 I, BRK I, and BRK 1 I.  Two of these, ESC 1 I and
BRK 1 I, affect only macro expansion.  ESC I and BRK I interrupt macro
expansion as well as other E processes, such as multipage searches.
Thus ESC 1 I or BRK 1 I can used when you want to stop a macro but don't
want to interrupt a search in progress.

Typing BRK I or BRK 1 I will terminate the current macro and return
control to any higher level calling macro.

Typing ESC I or ESC 1 I will terminate all macro expansion.  When this
mechanism is used to stop macro expansion, the user can have the
expansion resumed where it left off by giving the command ⊗XRESUME.

The ⊗XABORT command can be used to explicitly abort any number of levels
of macro expansion by popping a number of calls off the macro stack.
This command can be included in a macro definition to automatically end
one or more macro calls, or it can be given from the terminal to cause
the next ⊗XRESUME command to resume macro expansion one or more levels
up from the current macro stack location.  When given WITHOUT an
argument, ⊗XABORT stops all macro expansion--this form is meaningless
except inside a macro.  The ⊗#⊗XABORT command WITH an argument pops the
specified number (#) of macro calls off the macro stack (whether the
macro stack is actively being used or just being maintained for a later
⊗XRESUME).

Whenever all macros have been aborted before completion, the command

	⊗XRESUME<cr>

will resume macro expansion where it left off.  Also, the command

	⊗#⊗XRESUME<cr>

can be given with a decimal argument (#) to find out what macros are in
progress and what text and repeat arguments remain to be processed.  An
argument of ⊗# finds the element which is # calls from the top of the
macro stack and types out the remaining repeat count, the macro call
level, the name, and the remaining text of that macro call.  Thus ⊗0 types
the top of the stack, ⊗1 types the next element on the stack, etc.


PASSING REPEAT ARGUMENTS TO COMMANDS INSIDE MACROS: THE ⊗# COMMAND

The number-sign command, ⊗#, allows one or more commands inside a macro
to access and use the repeat argument given to a macro call.  (In this
paragraph and the table below, "#" represents the number-sign character
itself, NOT an arbitrary number.)  Inside a macro, each occurrence of
the ⊗# command passes the macro call's argument to the next command and
inhibits the repeated expansion of the macro (clearing the effective
repeat count of the macro call).  The actual argument passed to the
command following the ⊗# depends on the arguments given to (1) the macro
call and (2) the ⊗# command itself.  In the simplest case, if one of
these two arguments is omitted, the other is used.  If the argument to
⊗# is relative (preceded with ⊗+ or ⊗-), then the two (signed) arguments
are added together.  The following table shows the resulting argument as
a function of the two "input" arguments, with examples given in
parentheses.  Note that the macro call argument (if any) is always
positive; however, the ⊗# command can be followed by ⊗- to invert the
sign of the resulting argument.  Outside of macro expansion, the ⊗#
command is treated as if you had NOT typed it!

    Arg to        Arg to	 Resulting arg passed
  macro call	⊗# command	to command following ⊗#
 ------------  -------------    -------------------------
     none	 anything	Arg to ⊗# command
    (none)	  (⊗-⊗2)	(⊗-⊗2)

   relative	   none		Arg to macro call
  or absolute   or absolute
    (⊗+⊗5)	  (none)	(⊗+⊗5)
     (⊗5)	   (⊗2)		(⊗5)

   relative	 relative	Relative sum of the two arguments
    (⊗+⊗5)	  (⊗-⊗2)	(⊗+⊗3)

   absolute	 relative	Absolute sum of the two arguments,
				except negative sum is relative
     (⊗5)	  (⊗+⊗2)	(⊗7)
     (⊗5)	  (⊗-⊗7)	(⊗-⊗5)


REQUESTING/SUPPRESSING INFORMATIONAL MESSAGES: ⊗XVERBOSE AND ⊗XTERSE

Certain informational messages will be either typed out or suppressed
depending on the reporting state that E is in: Terse, Normal, or
Verbose.  The reporting state can be set with the ⊗XVERBOSE and ⊗XTERSE
commands, which are described elsewhere.  The Verbose state is useful
during debugging of macros that call other macros.

The following messages are typed out only in Verbose mode.

	Calling ...		;A macro is being called.
	Ending ...		;A macro call has just finished.

The following messages are suppressed only in Terse mode.

	Aborting macro ...	;An error has caused aborting of one
				; macro call while in ⊗XSTOPONE mode.
	Abort of # macros requested from ...
				;A ⊗#⊗XABORT command has been given.


FORMAT OF NAME TYPEOUT FOR MACRO CALL

When a macro call is mentioned in an error or informational message, the
form typed out is usually

	[nX](m)macname

where n is the remaining repeat count for this macro call, m is the
level of this macro call, and macname is the name of the macro.  The
form [nX] will be omitted if n is 1.  A level (m) of 1 represents the
bottom of the macro stack, that is, the level called from the terminal.
Note that macname might be blank, since the blank macro name is
perfectly legal.


LINE EDITING IN MACROS

Line editor commands may be used inside macros, and they will have their
normal effects except that the αD command, when intended to delete the
CRLF at the end of a line (thus joining two lines), MUST be preceded in
the macro definition either with α<tab> or with αK<cr> so that E will be
sure that the αD will be given at the end of the line.  The effect of a
bad use of αD is that characters after the αD in the macro definition
up through the first activation character following are not "typed"
until the macro expansion ends, which can be particularly noticeable if
you use a repeat argument on the macro call.


EXITING NOT ALLOWED DURING MACRO EXPANSION

The command to exit from E (namely, ⊗E) is not legal coming from a macro
expansion.  This is disallowed to prevent accidental exiting while using
attach mode inside macros, since the command to put down the attach
buffer is the same as that to exit, ⊗E.


*** ADDITIONAL COMMANDS RELEVANT TO MACROS ARE EXPLAINED ON THE NEXT PAGE. ***

MACROS AND COMMAND FILES: ⊗XEXECUTE ⊗PUTDEFS ⊗XCOMMENT ⊗XATTACH ⊗XREDEFINE
	(Additional commands relevant to macros are explained on p. 25.)


EXECUTING COMMANDS FROM A FILE

To allow macro definitions and other often used commands to be carried
out automatically, the ⊗XEXECUTE command causes a set of commands to be
read in from a specified command file and then executed.  The form of
this command is

    ⊗XEXECUTE <filename> ( <page range> ) <cr>

where <filename> and the parentheses and <page range> are optional.  This
causes the selected pages in the named file to be read into a macro whose
name is the file's primary name with a leading dot; then this "file macro"
is expanded just like any other macro.  If the <filename> is omitted, the
last execute filename given is used; if no previous execute filename has
been given, then the default filename is used: EINIT.CMD on your LOGIN
disk area.  If a <filename> without an extension is given in the ⊗XEXECUTE
command, the default extension .CMD is used.  With a zero argument, this
command

	⊗0⊗XEXECUTE<cr>

will just type out the current default execute file.  The <page range> can
be either a single decimal page number, or a pair of numbers separated by
a colon, (for example, 3:4).  Note that multiple page ranges (such as COPY
allows) are not permitted.

The ⊗XEXECUTE command ignores E directories and SOS line numbers and
accepts the standard and alternate representations to allow for input of
the CONTROL and META bits and non-printing characters from command files.
These representations, which use "⊗" as an escape character, are explained
on p. 25.


WRITING MACRO DEFINITIONS INTO COMMAND FILES: THE ⊗XPUTDEFS COMMAND

The extended command

	⊗XPUTDEFS <filename><cr>

writes all macro definitions into the file given, or into the default file
if no filename is specified.  If the file already exists, it is extended
with a new page added.  If the file doesn't exist, it is created with an E
directory.  This command has the same default file (initially EINIT.CMD on
your LOGIN disk area) and default file extension (.CMD) as the ⊗XEXECUTE
command.  The definitions are written out using the standard
representation, which is explained on p. 25.


COMMENTS IN COMMAND FILES

To allow documentation of macro definitions and other commands in command
files, the ⊗XCOMMENT command is provided.  This command does nothing; it
ignores the entire command line.  Thus the following command does nothing
inside a command file.

	αβXCOMMENT This is a bunch of text that can occur on many
	lines in a command file.  It might, for example, document
	what nearby text does.  This command should be ended with a
	carriage return, which in a command file must occur as the
	two characters circle-x and double arrow!  Any ALPHA
	character inside a comment in a command file must be quoted
	(as "⊗α") or it will generate the CONTROL bit on the next
	character and terminate the COMMENT extended command line.
	Similarly any other character combination that generates an
	activation character (like linefeed or altmode) will
	terminate the COMMENT command. ⊗↔


ATTACHING/EDITING/REDEFINING MACROS

The ⊗XATTACH and ⊗XREDEFINE commands can be used to edit and redefine
macros.  The ⊗XATTACH command loads the attach buffer with the definition
of a macro in standard representation (see p. 25), thus allowing you to
put the text into the current file and edit it.  The ⊗XREDEFINE command
(re)defines a macro from incore text, using the standard and alternate
representations.  The forms of these commands are

	⊗XATTACH <macro name><cr>

	⊗#⊗XREDEFINE <macro name><cr>

where the blank macro name will be used if <macro name> is omitted and the
argument (#) to ⊗XREDEFINE determines how many lines (starting at the
current line or at the first line of the attach buffer) are used as the
source of the macro definition.  As usual, a negative argument represents
lines before the current line.  If no argument is given to ⊗XREDEFINE, the
whole page or whole attach buffer is used as the macro definition source.
The ⊗XATTACH command cannot be given when there is already some text
attached.
BOOK MODE (/B) and the BOOK command

Book mode (/B) in E provides some special features for editing files,
especially files which are really books in disguise.  The main feature
of book mode is that you cannot alter a file open in this mode.  In
addition, the BOOK command allows you to read a file in book mode over a
long period of time without having to explicitly remember your place in
the file.  Your place will be saved in a .BKP file.

You get into book mode by following the filename with /B when you are
starting to edit, or by using the BOOK command to edit the file.

1. In /B mode, E will never permit you to alter the file you are
editing; you cannot change to READONLY mode or READWRITE mode from /B
mode.  In /B mode, if you change part of a page and try to write out
the new version, E will simply remind you that you cannot alter the
file.

2. To help you keep your place in a book-file you are reading, E
keeps a special psuedo-SNAIL file on your area.  This file will have
the name <filnam>.BKP, where <filnam> is the primary name of the
book-file.  Note that the .BKP file is NOT a SNAIL file (although it
is in SNAIL file format), and thus will never be deleted by LOGOUT.
This .BKP file will contain the page number and line number at which
you were editing the book-file the last time you exited from E.  E
will neither look for nor write a .BKP file unless you have started E
with the monitor command BOOK, which automatically starts E in /B
mode looking for a .BKP file.  Furthermore, when you start E with the
BOOK command, if you use either of the /L or /P switches, E will
not read or write any .BKP file.  And if you start E with just the
BOOK command without any argument, then unless there already is
a .BKP file on your area, no new .BKP file will be written.

3. The BOOK command with an argument (and without either of the /L
and /P switches) will look for a .BKP file with the given name and
PPN.  If that .BKP file is not found, E will look for the .BKP file
on your current ALIAS area and then on your logged-in area.  If a .BKP
fihα0¬ is found, it is used and updated when you exit.  Otherwise, a
new .BKP file will be written onto your (ALIAS) area when you exit.

4. Whenever you use E in /B mode, it will reference TMPCOR files with
the name BK instead of ED.  Thus you can switch back and forth
between editing some program and reading a book by alternately giving
the no-argument monitor commands ETV and BOOK (provided you have once
given the filenames).  In /B mode, E will display "/B" following the
filename at the top of the screen.

5. When you have finished reading a book-file, E will delete the
<filnam>.BKP file automatically.  E will think you have finished
reading the book if and only if you are on the last page of the file
when you exit.

- - - - -

The complete book WUTHERING HEIGHTS by Emily Bronte is available for
general reading in the file WUTHER[LIB,DOC].  To begin reading it,
simply give the monitor command:

.BOOK WUTHER[LIB,DOC]

Then when you exit from E, the file WUTHER.BKP will have been written
onto your (ALIAS) disk area with umbers of the page and line
where you were last reading.  To continue reading the file later
during the same login session (and with the same ALIAS as before),
simply say:

.BOOK

which will read in the TMPCOR file BK for your current ALIAS.  When
you exit again, the TMPCOR file and the .BKP file will be updated.

To continue reading after you have logged out and back in, say:

.BOOK WUTHER

which will cause E to find your .BKP file, which itself will contain
the name of the book-file WUTHER[LIB,DOC].

Some other book-files will be found on the [LIB,DOC] disk area, including
GRIMM which is Grimm's Fairy Tales.

- - - - -

To read a file in /B mode without having the <filnam>.BKP file read
or written, use the /B switch explicitly:

.ETV <filename>/B

E files extended by other programs.

E can handle easily almost any file that has been extended by another
program even though the directory has not been updated by that program.
The single restriction is that the file must remain in correct E format
with Formfeeds occurring only as the first character in a record.  When
E encounters a file that is longer than the directory indicates, the
file is read from the last indicated page to the end of the file to make
sure that the file is properly formatted.  If the file is formatted ok,
then E generates in core an updated version of the directory, including
directory lines for any new pages added to the file.  The updated
directory is normally not written out onto the disk until some command
forces one or more other pages to be written on the disk.  However, the
⊗XUPDATE command immediately writes out the updated directory, if any.
As long as the updated directory remains not written out on the disk, a
"U" (for update) is displayed on the top line of the screen.  The first
time any page is changed and written out, or when the ⊗XUPDATE command
is given, the updated directory will be written out and the "U" will
disappear.

When E opens a file that has been properly extended in the above manner,
it reports the number of pages that have been added to the file, or, if
none, the number of records by which the last page has been extended.
Also, if any pages have been added, the default position within the file
(at which E will place you if you gave no specific page number in a /#P
switch) is the first newly added page.

MAIL and RCV extend E files in this way.
Filenames, numeric extensions, and filehacks

FILENAMES

If the filename you select to edit does not include an extension, then E
will first look for the file with the null extension.  If that file does
not exist, E will edit the file (with the given primary name and PPN)
that has the "best" extension.  The "best" extension is found by
checking extensions against E's ordered list of good extensions (i.e.,
.FAI, .SAI, .PUB, etc).  If no good extension is found, E will edit the
first file it finds in the UFD that has the right primary name and any
extension except those in E's bad extension list (e.g., .DMP, .XGP,
etc).  To edit a file with a "bad" extension, you must type the
extension explicitly unless the file with the "bad" extension is the
only file in that disk area with the given primary name.

If you omit the programmer name from the PPN in a filename, E will use
your current alias programmer name.  If you omit the project name, E
will use your current alias project name.


NUMERIC FILENAME EXTENSIONS

You can ask E to edit the file with a given primary name and the
greatest numeric extension by giving the extension consisting of just a
greater-than sign (">").  For example,

	ET FOO.>

will edit the file (with primary name FOO) whose extension is the
largest (purely) numeric value.  E.g., if only FOO.20 and FOO.100 exist,
then ET FOO.> will edit FOO.100.  If no file is found with a numeric
extension, then ET FOO.> will report File Not Found: FOO.>.


FILEHACKS

The following filehacks, also usable with the COPY program, are
available in E as filenames.  The file represented by each is indicated
below; all these files are on the [2,2] disk area.  A filehack consists
of a backslash followed by a name from the list below; the name may be
abbreviated by as many letter as necessary to identify it uniquely
(current abbreviations are given below).  A filehack takes the place of
the filename and can be followed by the usual switches.  Note that some
of the files below are not usually maintained in E format; beware.

Some of these filehacks imply /R mode.  These are indicated in the list.
To override a default /R mode, you can explicitly specify /-R after the
filehack.

FILEHACK  ABBR  /R?  FILE
\MAIL	  \M	No   The current user's mail file.
\MSG	  \M	No   The current user's mail file.
\PLAN	  \P	Yes  The current user's plan file.
\PLN	  \P	Yes  The current user's plan file.
\NAP	  \NA	Yes  The current user's NS notifications file.
\NS	  \NS	Yes  The current user's NS notifications file.
\GRIPES	  \G	No   The system gripe file: GRIPES.TXT[2,2].
\GOLD	  \GO	No   The file of old system gripes: GRIPES.OLD[2,2].
\NOTICE	  \NO	Yes  The system message file: NOTICE.TXT[2,2].
\DIGEST   \DI	Yes  The current AP news digest.
\DOWN	  \DO	Yes  The system downtime forecast file.
\DAY	  \DA	Yes  The message-of-the-current-day file.
\FORWARD  \F    Yes  The forwarding file for the MAIL system.

The filehacks \MAIL, \MSG, \PLAN, \PLN, \NAP and \NS can have an
explicit programmer name specified, in which case the mail, plan, or
notification file for the named programmer is read instead of your own.
To specify a programmer name, follow the filehack name immediately with
a colon (:) followed by the desired programmer name.  For instance,
\MAIL:FOO represents FOO's mail file, and \PLAN:BAZ is BAZ's plan file.
The ⊗XPOINTER command will recognize these programmer-name filehacks (as
well as the normal filehacks).  The filehack names themselves can be
abbreviated as usual (e.g., \M:FOO is FOO's mail file).  The
programmer-name filehack facility is designed for non-display users,
since display users could already enter a filename like ∂FOO or
∂BAZ.PLN.


EDITING THE E MANUAL FILE, E.ALS[UP,DOC]

The special filename consisting of just a question mark ("?")
represents the name of the E manual (this file).  Thus the monitor
command

	ETV ?<cr>

will cause E to edit this manual file in readonly mode.

Generating a new directory line: ⊗XNDFAIL ⊗XNDSAIL

Two commands ⊗XNDFAIL and ⊗XNDSAIL generate and insert a new first line
of the page (called the directory line) in appropriate FAIL and SAIL
formats for labels and for specified categories.

These commands apply to the current page.  If more than one page is in
core (through the use of ⊗XAPPEND or β<ff> commands) then the
information will be gathered only from the page containing the arrow
line and the new line will appear at the start of this page.  Other
pages in core at the time will be unaffected.

	The ⊗XNDSAIL command may be used as an information source in a variety
of different ways.  It is not intended for use with text material.

⊗XNDFAIL
	Given with a <cr> termination, lists all labels.
	Given with a α<cr> it lists only those labels that have one or more ↑'s
	Given with αβ<cr> it lists only those labels with ↑↑ (or more).

	This command does not take arguments (unlike ⊗XNDSAIL).  If the command is
	typed with a prefix argument of 0, it states the conditions outlined
	above and is otherwise a NO-OP.

⊗XNDSAIL
	Given with a <cr> termination, lists all words that are preceded by
	certain category words, the default words being RECORD!CLASS,
	RECORD_CLASS and PROCEDURE.

	Having found a category word the program lists the first word following
	the category word and then ignores any following text until either a comma
	or a semicolon is encountered.  When a semicolon is encountered the search
	for a new category word is resumed.  If, on the other hand, a comma is
	encountered (not however within parens) then the next word is taken as
	another example of the category and it is listed, preceded by a comma.
	Listings following different category words are separated by spaces.

	The default categories may be augmented or replaced by any desired
	categories up to the limit of 4 categories, as outlined below.

	One additional category may be specified by typing its name after a
		space following the command name and terminating it by a <cr>.
	Up to 4 new categories may be specified (separated by commas) with the
		categories after the first one replacing the default
		categories, one by one.  To retain some default categories the
		list is terminated by a <cr>.
	If the typed list of categories is terminated by ⊗<cr> then only the
		typed categories are used, and the default ones are eliminated.
	If the command is terminated by ⊗<cr> without any typed category names
		then the original default categories are reinstated.

If given with a prefix argument of 0 this command will accept any  typed
categories and then will list the categories that are in effect  without
generating a text line.
Major changes have been made to the JUST and JFILL commands (9/5/76).
		     (See p. 16:18 for full details.)

1)  Lines of any length can now be handled by these commands.

2)  Left margins are now specified in terms of indent values, that is, one
    types 0 (not 1 as formerly) if the line is have no indent.  The  right
    margin is still specified by the column position.

3)  The number of blank lines (B) to be used between paragraphs may now be
    specified by typing  a fourth  suffixing number  (it may  be 0).   The
    initial default situation is for the same number of blank lines to  be
    used after justification  as there  were in the  original text.   This
    condition may be reset by typing -1 as the fourth number.

4)  All margin values are now sticky.  The initial default values are now
    0,0,74,-1.

5)  Switches are now used to change  the way that  E  detects  paragraphs.
    The initially set switch, N, (for Normal) calls for any indent ≥2  (or
    a TAB) to signal a new paragraph.  An Arbitrarily input crown indent A
    may, however, be assigned and used  by means of the switches as  noted
    below.  Switches are sticky and are typed as a single letter following
    the command name, separated from it and from any following  parameters
    by spaces.  For fuller details see p. 16.

Switch	Mnemonic 	Conditions in old text identifying a new paragraph
				(Besides preceding blank line)
N	Normal		Normal crown indent ≥2
G	Get		Get Assigned crown indent A by examining text.
R       Rejustify       Rejustify (old C as new A input crown indent)
A	Assigned	Use Assigned crown indent A (as previously determined).



Other changes to these commands

1)  Punctuation marks . ! and ? followed by a space, even with any number
    of closure symbols (such as ", ), ], etc.) interposed, are treated as
    sentence endings and will be followed by 2 spaces (or a CRLF) when the
    text is justified provided the final closure symbol was originally
    followed by 2 spaces or a CRLF.

2)  The fast indent  commands ← and  → now use  the absolute indent  value
    associated with the  last use  of the ⊗XINDENT  command.  The  initial
    default value is 4.

3)  Indents can no longer be specified relatively.  This feature was seldom
    used and it could be interpreted ambiguously.

4)  All left margin indents now use TABs whenever possible.

5)  THE INDENT and ALIGN now take  switches that specify the way in  which
    interior TABs are  to be handled.   With the S  switch operative,  and
    this is  the default  condition,  all interior  TABs are  replaced  by
    spaces before anything else is done.  With the T switch operative TABs
    are left as TABs.

6)  A negative prefix argument may be used to justify the specified number
    of lines before (but not including) the arrow line.

		  Seven new commands  have been  added.

    These commands  facilitate  the  justification  operations,  both  for
normal text and  for tabular material.   All of the  this explanation  was
justified by means of these new commands.  See p. 16 to 18 for details.
These new commands are noted below.

⊗XJGET  This command examines test to determine the C,L,R values that were
    used in it  justification so that  other unjustified text  can be  put
    into the same form.

⊗XSJFILL  This command separates the text into separate sentences so  that
    the sentences can be reordered as desired.

⊗XSJUST  Similar to ⊗SJFILL but the sentences  are padded so as to  obtain
    right-margin justified as well.

⊗XTABLE  This command  allows  one to  change  the columnar  positions  of
    tabular text that is already  in proper columnar arrangement with  due
    allowance being made for empty entries.

⊗TJFILL  This command handles tabular material that is not in columns  and
    puts  it  into  any  desired  columnar  arrangement.   There  may   be
    associated textual material which will be left justified.

⊗TJUST  Similar to ⊗TJFILL  but the associated  textual material is  right
    justified as well.

⊗XTJGET  This command  does  for tabular  material  what ⊗XJGET  does  for
    ordinary text.
⊗N,⊗O,⊗H: Line, Page & File stacks. ⊗XHOME ⊗XBACKGO ⊗XZFILES ⊗XZPAGES ⊗XZLINES

The commands ⊗N,⊗O,⊗H make use of three corresponding "stacks" of places
you've been at recently: the LINE STACK (⊗N) of lines currently in core,
the PAGE STACK (⊗O) of pages NOT currently in core, and the FILE STACK
(⊗H).  Each of the ⊗N,⊗O,⊗H commands works with the corresponding stack;
all of these commands interpret arguments in the same way and all
distinguish between α<cmd> and αβ<cmd>.  You can return to the #th
previous place, and/or you can "Pop" # places off the stack, and/or you
can "re-Push" # places back on the stack.

The ⊗XBACKGO command is identical with the ⊗O command.

In the descriptions that follow, any sentence referring to "the stack"
should be taken as applying to each of the three stacks.  The word
"place" is used to mean "line", "page", or "file", depending on which
stack is being considered.  The current place is always at the top of
the stack.

The basic forms of these three stack commands are the "single-bucky" (α)
commands αN, αO, and αH, which, respectively, will take you back to the
previous line, page, or file.  If a simple numeric argument ⊗# is added,
then you will go back to the #th previous line, page, or file (e.g.,
⊗3αH will take you to the third previous file).  If you give an argument
greater than the current size of the stack, then you will end up at the
place formerly on the bottom of the stack.

The double-bucky (αβ) forms of these commands (without arguments: αβN,
αβO, and αβH) are just like the single-bucky forms except that the
current default argument for the command is used.  The default arguments
(kept separately for each of the three commands) are all initially 2.
Thus, for example, αβO will initially take you back to the second
previous page.  The default argument for a double-bucky command is
changed by typing the double-bucky command with the desired future
default.  Note that this both sets the default argument and executes it!
For example, ⊗5αβH takes you to the fifth previous file and sets the
default arg for subsequent αβH commands to 5.

Note that with the default argument set to some number J, repeated use
of the double-bucky command with no argument will cause you to loop
through J+1 places.  Thus when you are working on J+1 pages (or lines
or files) which you want to loop through, it is useful to set the
default arg to J.

You can find out what is on any of the stacks or what the default arg is
for any of the double-bucky commands by using an argument of zero (⊗0).
A zero arg with a double-bucky command types out the default arg for the
double-bucky command.  A zero arg with a single-bucky command types out
the corresponding stack, including the current place (which is at the
top of the stack).  Thus ⊗0αN types out the line stack and ⊗0αβO types
out the default arg for the αβO command (without executing it).

Since the lists of recently visited places have been called stacks,
there must be some stack adjusting operations -- and there are.  Except
when one of the below stack adjusting operations has been used, the
"stack" is really an ordered list of the most recently visited DISTINCT
places.  The list is ordered by the recentness of your being at each
place, and the places are kept distinct by removing from the middle of
the stack any entry for the place you are currently at.  The current
place is always the top entry in the stack.

The STACK ADJUSTING OPERATIONS all involve a RELATIVE argument being
given to one of the ⊗N,⊗O,⊗H commands.  There are two possibilities:
the relative argument can be negative (⊗-⊗3) or positive (e.g., ⊗+⊗4)
(note that ⊗5 is not a relative argument).  Negative arguments cause
"Popping" of places off the stack and positive arguments cause
"re-Pushing" of places back on the stack.  The default value for a
relative arg is one (i.e., ⊗+⊗N means ⊗+⊗1⊗N, and ⊗-⊗O means ⊗-⊗1⊗O).
You cannot pop or re-push more places than there are on the stack.

A NEGATIVE RELATIVE argument causes the given number of places to be
"Popped" off the top of the stack and the user is moved to the new top
of the stack.  This is useful if, having gotten somewhere, you decide
you're not interested in remembering that place on the stack and you
want to go back to some previous place.  For example, ⊗-⊗N (default
number is 1) will take you back to the previously remembered line and
not leave an entry for the current line just one below the new top of
the stack (as αN would).  Actually, when you "pop" a place off the
stack, it is remembered (for the "re-push" command) by putting it on the
bottom of the stack.

A POSITIVE RELATIVE argument (e.g., ⊗+⊗4) causes the given number of
places to be "re-Pushed" onto the top of the stack from the bottom of
the stack and you are then moved to the new top of the stack.  This is
mainly useful if you have just popped one or more places off the stack
and then decide you want another look at such a place.  For example, if
you do a ⊗-⊗N, then doing a ⊗+⊗N immediately will undo the ⊗-⊗N
(including both returning you to a particular line and restoring the
stack to its previous state).  Of course, if you haven't popped anything
off the top of the stack, then what gets pushed onto the top isn't
really "re"pushed after all, but is just whatever happened to be sitting
at the bottom of the stack.


Now for some details pertaining to particular stacks.


The line stack:

The line stack only remembers lines that are more than four (4) lines
away from each other.  (Remember, the current line is the top of the
stack.)  Thus moving down the page by ⊗> does not leave a trail of
remembered places, but in fact flushes from the middle of the line stack
the entries for any lines that are approached (within four lines).

When you go to a different page (not already in core), your line stack
is lost irretrievably.  It is not restored when you return to a
previous page.

Entries in the line stack are corrected for line insertions and
deletions, including those resulting from the attach and justification
commands.  The ⊗XCANCEL command preserves the current line stack without
attempting to un-correct entries for lines previously inserted or
deleted, but it flushes entries for lines that no longer exist (i.e.,
are beyond the new last line in core).

Multiple consecutive FF and VT (and ⊗W) commands do NOT remember (on the
line stack) intermediate stopping places.  But ANY command besides FF,
VT, ⊗W, and ⊗0⊗N will cause the current line to get remembered.  While
you are FF/VTing around a page, the αN command will take you back where
you started the current string of FF/VT commands (even if you are
already there!) and will remember, of course, the line you are leaving.

With each line in the line stack, E remembers the window position that
existed when you left that line.  When you return to a line via ⊗N, the
old window position associated with that line is restored unless the line
was already on the screen, in which case the window is not changed.


The page stack:

Each entry in the page stack contains not only a page number, but also
the line number and window you were at when you left that page.  The
⊗O command restores this line number and window.

When you return to a previous file (whether by number or by explicit
filename), the top part of your page stack from that file is restored
along with all line marks from that file.

If you ⊗XAPPEND to the current incore page(s) a page that was remembered
on the page stack, its entry in the stack is flushed since the page is
now in core.


The file stack:

Whenever you return to a previous file with one of the ⊗H, ⊗ε, ⊗λ and ⊗?
commands, the file is opened in the mode that you were in when you left it
(e.g., /N), and at the page and line where you were when you left it.  The
window position is also restored.  Whenever you return with the ⊗H
command, your Readonly/Readwrite mode is restored to its previous state
for that file.  If you return to a previous file by using the ⊗ε or ⊗λ
command without an arg (and typing the filename explicitly), you can
override the default starting page and line with switches.

The E manual (this file) is never remembered in the file stack if you
get to it via the ⊗? command or the ? filename.  Thus when you say ⊗?,
the first subsequent αH command will take you back to the file you
previously were in and a second αH will take you back, not to E.ALS,
but to the second previous file you were in prior to entering E.ALS.


The (⊗+ or ⊗-) ⊗#⊗XHOME command:

You can get back to the previous file in the stack AND AT THE SAME TIME
TO A SPECIFIC ABSOLUTE OR RELATIVE PAGE by using the ⊗XHOME command.  An
absolute argument will position you to that page as you return to the
file, and a relative argument will position you that many pages from the
page where you would have otherwise returned.  Thus ⊗4⊗XHOME will return
you to the previous file on page 4.


CLEARING THE STACKS:

The extended commands ZFILES, ZPAGES and ZLINES clear the file, page
and line stacks respectively.

    ⊗X ZFILES        Zero (clear) the file stack.
    ⊗X ZPAGES        Zero (clear) the page stack.
    ⊗X ZLINES        Zero (clear) the line stack.